#dev community

View On WordPress

Lessons learned from messaging strangers on the internet This post is based on a talk I gave at the Geek Sessions meet-up in Faro, Portugal 🇵🇹 on the 28th of June, 2023. The full title for this talk was "Lessons learned from messaging strangers on the internet in a language I did not speak" and the idea here is to draw some parallels between the idea of learning new (spoken) languages and learning new skills in technology. Back in June 2020 I was very bored and in lockdown, like most folks, and decided that I needed to learn something in order to keep sane. Being the language nerd that I am I decided I was going to learn Spanish. Since I couldn't just learn the basics and then take a two week holiday somewhere in Spain to practice I needed to decide how I was going to approach it before I could get started. The Plan As I am a native speaker of Brazilian Portuguese I thought this was going to be a quick and easy exercise. Just how I thought the pandemic and the lockdowns would be over before the end of summer or by halloween. Boy was I wrong... So my idea was simple: I'd exchange at least 50 messages a day with a number of people using language learning chatting apps Watch videos in Spanish with Spanish subtitles. Money Heist taught a great Italian song (and some Spanish too!) Start listening to music, and later podcasts, in Spanish Armed with a sound plan and a fool's confidence, I set my target language to Spanish in HelloTalk and got to work! How did it go? As it turns out, knowing Portuguese didn't help nearly as much as I thought it would. Brazilian Portuguese has a much simpler grammatical structure, which meant that whilst I could read messages and take a second to understand which grammar tense was being used, I couldn't really keep up with people's audio messages or Youtube videos and series. Added to that, whilst there's an overlap of about 90% of vocabulary between the two languages, this overlap doesn't help as much as you'd think. Some words have slightly different meanings, have fallen out of fashion in one language or the other, or just sound straight up embarrassing and you didn't even know it. I was always looking words up on either SpanishDict or using Google Translate, DeepL and the apps' builtin translation tools. After about 6 months I was already better at writing and didn't need to rely so much on SpanishDict for verb conjugations of regular verbs and the most common irregulars like ser, estar, ver and a few others. At about the 9 to 12-month mark I started being able to speak a few sentences without having to write them down first. My accent was horrible but at least I was able to alternate between audio and written messages during my practice. Then After about 18 months I started to recall things quicker, expressing myself and having more in-depth conversations with others become much easier. I no longer needed subtitles and became able to listen to audiobooks and podcasts, some even at 1.5 or 2 times the normal playback speed. Around this same time I also started to develop a kind of intuition for verb conjugations I didn't know, and was able to use some of the less common verb conjugations in speech without the need to look them up in a dictionary. Now About three years into this learning journey my language level has oscillated between a good B2 and an acceptable B1. I've had the opportunity to travel to Spain a few times and spend time there with friends speaking mostly Spanish for a number of days in a row each time. After being in a Spanish speaking environment for about a day I am very much back at my best. My accent is still inconsistent, I'll very quickly start mirroring whichever accent is spoken around me and then use expressions and vocabulary that may not be as common or native to where I am, e.g. using Mexican or South American words whilst speaking to a Spanish person. I don't mind this as much as I used to, I would like to have a more consistent accent but I've come a long way and I feel like I have achieved way more than what I had originally set out to achieve. Parallels between skilling up in technology and learning a spoken language Now that I've given some context of my learning journey, let's shift our attention to some of the things I've identified in my process that could also be used to improve our experience when learning new skills in tech. Learning can be a very personal experience and different people will have different ways in which they prefer to acquire new skills, for the purposes of my talk I chose to focus on a few more general points in order to try and make it as useful and relatable to as many people as possible. These are the five points I want to touch on: 1. Identify your goals Before you start you should identify your goals, this will help you with checking in on your progress along the way. These are a few of the questions you can ask yourself to try and understand: What do you want to do with this new skill? How will you know when you've achieved it? How strict are you about those answers? Will there be a next level after you're done with this one? These questions are not comprehensive but should be a great starting point. I find it specially useful to know how flexible I can be with the goal as I progress and how well documented my goal setting needs to be. For professional goals we're usually required to have a more detailed description and be more strict with our definition of done. Personal goals can go from a mental note to a full blown schedule, depending on what it is that you're aiming for. 2. Take small steps Now that you've determined what the end of the journey should look like, let's go back to the start. For almost any skill in technology it pays off to really understand the foundations of what you're learning—you should learn to walk before you try to run. If you're learning a programming language you should focus on the basics of its syntax and peculiarities first, e.g. understand the basics of Rust's ownership system, or Javascript's asynchronous nature. It's also a good idea to start with some tutorials or books that will walk you through these basics and then start to experiment with the simpler examples that you see, exploring things in your own way. If you're trying to learn a new skill that is more role specific, like DevOps, then perhaps you can start with understanding the basics of Docker, Kubernetes and what it takes to deploy a "hello world" style app using such technologies. The main goal at this point is to start small so you can find your pace. Learning shouldn't be overwhelming, nor boring. After the talk we had a small QA session and one of the questions was about how can we know whether we're doing too much or too little when trying to learn. A good analogy I came up with for the case of spoken languages was: if you're dreaming in your target language, you're good, if you start losing sleep over it then it is too much. I don't expect anyone to measure their learning effort of Rust or Haskell by how much they dream about these languages but this is still a good analogy in terms of the levels of exposure to the thing you're trying to learn and how much you should make it a part of your daily life. This takes us to the next point... 3. Practice regularly and immerse yourself in the technology In order to learn a new skill effectively you need to be able to incorporate as much practice as possible into your daily life. In the case of spoken languages this is obvious and easier to define. You should be listening to music, watching videos in the target language and speaking to natives or fluent speakers of that language as much as possible. For technology things can be a little bit trickier. It is unlikely that you'll be able to get a job utilising a skill that you've just started to learn when it comes to tech, in order to counter that you'll have to find other ways to immerse yourself into the tech area you're trying to learn. The most obvious way to get exposure to the thing you're learning is by practising it. Building low stakes projects will be the most effective way to achieve this as you can try different things out without running the risk of having a bigger impact on things around you. Then after that I would recommend listening to podcasts, reading blog posts, books, developer documentation, watching conference talks (online and in-person if possible), joining communities online around the topic that you're trying to learn (more on this later). These are all great options and you should try and mix and match them as and when you can, so long as you incorporate some kind of daily practice on your routine you will see the value in this effort in no time. 4. Embrace your mistakes Mistakes are a very natural part of learning. Regardless of whether we're just getting started or have been practising for a little while, it's obvious that we will make many mistakes along the way. You should learn to be comfortable with your mistakes early on, in order to avoid frustrations. As briefly alluded to in my previous point, having low stakes settings for your practice is one way to help you be more comfortable with making mistakes. Another point that is worth noting is that mistakes can also be used to give us more perspective on what we're learning. Whenever you make a mistake, be it one that makes it so your code doesn't compile or something that someone else is telling you shouldn't be done in that way you can ask yourself why is it that this is not how it should be: Did you break a hard rule by making a syntax error or referencing a variable or file that doesn't exist? Did you not follow best practice and are now running into unexpected behaviour? Did you rely on a feature of the language you're learning that you didn't fully understand and now don't know why it isn't doing what you hoped it would? Mistakes in programming and other aspects of technology can come in different shapes and forms but they're a great way to help us understand what it is that we're lacking in terms of knowledge so that we can work to fill that gap. Another great way to use our mistakes as a positive part of our growth is by having a mentor or community that can help you to keep moving when you're struggling to understand something or to get it to work as intended, this takes us to the last point I want to touch on... 5. The importance of focused communities There will always be other learning or using the same things you're trying to learn, if you can find a good group of people to learn with or at least exchange some of your experiences the synergy it creates can drastically improve your learning journey. Furthermore, by participating in communities you will likely start to meet people that could eventually help you on a professional level too, or that you may be able to help them. I strongly recommend trying to find local communities for this as well, for offline meet-ups and events. These will usually have an online side to them but being able to get together and meet people, join hackathons or other events where you also get to do things alongside others can really help the immersion part of learning. Another, possible less obvious, benefit of being part of more focused communities is that it helps with staying motivated. Very often in our lives things will happen that will force us to set things aside for a short period of time or deprioritise something in favour of a more pressing issue. When this happens, being part of a community and attempting to stay active will serve as a reminder of your learning journey and how you should continue to try and learn as much as your available time allows. Conclusion That's it! I understand that this is by far not a comprehensive list but I hope it helps you when you next try to learn something from scratch or even on your current learning journey. You can find the slides for my original talk in here and the source code for the slides on my Github. Share in the comments below what sort of techniques or tips you keep coming back to when learning and what you are trying to learn now. Me, I'm currently trying to learn more of the Rust programming language, as it's a compiled, lower level, language and I've never really done anything with compiled languages before. https://dev.to/leomeloxp/lessons-learned-from-messaging-strangers-on-the-internet-2m57

JavaScript is cool (don't @ me), but how can a machine actually understand the code you've written? As JavaScript devs, we usually don't have to deal with compilers ourselves. However, it's definitely good to know the basics of the JavaScript engine and see how it handles our human-friendly JS code, and turns it into something machines understand! 🥳 | Note: This post is mainly based on the V8 engine used by Node.js and Chromium-based browsers. The HTML parser encounters a script tag with a source. Code from this source gets loaded from either the network, cache, or an installed service worker. The response is the requested script as a stream of bytes, which the byte stream decoder takes care of! The byte stream decoder decodes the stream of bytes as it’s being downloaded. The byte stream decoder creates tokens from the decoded stream of bytes. For example, 0066 decodes to f, 0075 to u, 006e to n, 0063 to c, 0074 to t, 0069 to i, 006f to o, and 006e to n followed by a white space. Seems like you wrote function! This is a reserved keyword in JavaScript, a token gets created, and sent to the parser (and pre-parser, which I didn't cover in the gifs but will explain later). The same happens for the rest of the byte stream. The engine uses two parsers: the pre-parser, and the parser. In order to reduce the time it takes to load up a website, the engine tries to avoid parsing code that's not necessary right away. The preparser handles code that may be used later on, while the parser handles the code that’s needed immediately! If a certain function will only get invoked after a user clicks a button, it's not necessary that this code is compiled immediately just to load up a website. If the user eventually ends up clicking the button and requiring that piece of code, it gets sent to the parser. The parser creates nodes based on the tokens it receives from the byte stream decoder. With these nodes, it creates an Abstract Syntax Tree, or AST. 🌳 Next, it's time for the interpreter! The interpreter which walks through the AST, and generates byte code based on the information that the AST contains. Once the byte code has been generated fully, the AST is deleted, clearing up memory space. Finally, we have something that a machine can work with! 🎉 Although byte code is fast, it can be faster. As this bytecode runs, information is being generated. It can detect whether certain behavior happens often, and the types of the data that’s been used. Maybe you've been invoking a function dozens of times: it's time to optimize this so it'll run even faster! 🏃🏽‍♀️ The byte code, together with the generated type feedback, is sent to an optimizing compiler. The optimizing compiler takes the byte code and type feedback, and generates highly optimized machine code from these. 🚀 JavaScript is a dynamically typed language, meaning that the types of data can change constantly. It would be extremely slow if the JavaScript engine had to check each time which data type a certain value has. In order to reduce the time it takes to interpret the code, optimized machine code only handles the cases the engine has seen before while running the bytecode. If we repeatedly used a certain piece of code that returned the same data type over and over, the optimized machine code can simply be re-used in order to speed things up. However, since JavaScript is dynamically typed, it can happen that the same piece of code suddenly returns a different type of data. If that happens, the machine code gets de-optimized, and the engine falls back to interpreting the generated byte code. Say a certain function is invoked a 100 times and has always returned the same value so far. It will assume that it will also return this value the 101st time you invoke it. Let’s say that we have the following function sum, that’s (so far) always been called with numerical values as arguments each time: This returns the number 3! The next time we invoke it, it will assume that we’re invoking it again with two numerical values. If that’s true, no dynamic lookup is required, and it can just re-use the optimized machine code. Else, if the assumption was incorrect, it will revert back to the original byte code instead of the optimized machine code. For example, the next time we invoke it, we pass a string instead of a number. Since JavaScript is dynamically typed, we can do this without any errors! This means that the number 2 will get coerced into a string, and the function will return the string "12" instead. It goes back to executing the interpreted bytecode and updates the type feedback. I hope this post was useful to you! 😊 Of course, there are many parts to the engine that I haven't covered in this post (JS heap, call stack, etc.) which I might cover later! I definitely encourage you to start to doing some research yourself if you're interested in the internals of JavaScript, V8 is open source and has some great documentation on how it works under the hood! 🤖 V8 Docs || V8 Github || Chrome University 2018: Life Of A Script Feel free to reach out to me! Twitter || Instagram || GitHub || LinkedIn FAQ: I use Keynote to make the animations and screen record it lol. Feel free to translate this blog to your language, and thanks so much for doing so! Just keep a reference to the original article and let me know if you've translated it please! 😊