Creating embedded systems using C++ or C code.
Communicating between several peripherals through SPI & I2C busses.
On what basis can we say that someone mastered a specific programming languages?I have six criteria that evaluates someone's proficiency in a specific programming language. The following criteria is divided from top to bottom based on the order of proficiency from beginner, intermediate, to higher levels.
Typically, this goes over the generic logic blocks: such as if, else, else if, for, while, and switch-case statements, also creating function definitions and lambda functions. As well as determining the available primitive types, like int, float, char, string or arrays. And, whether the language is statically typed or dynamically typed and strongly typed or weakly typed.
Languages may be object oriented or not, so classes, interfaces, and traits may or may not exists in some other languages. Functional languages may like to use functors more often than typical syntaxes, so retaining commonly used functors may be essential. Some modern language may introduce new logic blocks, like Rust's if-let or loop statements. Compile-time and run-time syntaxes may behaved differently requiring deeper understanding of languages with a build step. Generally, involves gaining a deeper understanding of the language's compiler or interpreter.
Each languages may implement common data structures differently, such a map may be refered to as a Hash Map or as an Object prototype in other languages, and maps may be ordered and/or unordered depending on the language. Same goes for every possible implementation of a linked list, such as doubly-linked, single-ended, or double-ended, wherein other languages just opt to only implement a doubly-linked list. As an extension, remembering commonly used dependecies found and installed through a languages' package manager may be helpful. Extensive knowledge of libraries and module provides a keen insight for instances such as: a project requiring a package that can quickly implement JSON Serialization/Deserialization; or finding a well-maintained and adaptable image processing libraries; or debating between using a quick and accessible network communication interface or for a more flexible one.
This involves utilising advanced features of the machines such as multithreading, asynchronous tasks, coroutines, and performing networking IO. Applications of aforementioned concepts can be applied in creating ACID functionalities, scheduling job queues, or communicating with several peripherals effectively
For lower level languages, it is essential to deallocate every dynamically allocated memory to prevent undefined behaviour and segmentation faults within a program. But for higher level languages, it is also essential to explicitly identify the type being used in a certain context especially for weakly & dynamically typed languages like JS. This also include, defining operator overloads to make custom types integrate naturally with the language's syntax/functors.
Nothing proves someone's proficiency more than actually using the language to create something. It enlightens programmers on how to actually use the language in the context of applying it to an actual problem. And, it naturally reveals the limits and strengths of a language as the project scales in scope and size. Some of the aforementioned proficiencies are naturally developed as you go through a project. And, applying programming knowledge to coding projects will intuitively help retain problem solving skills from problems that pop up naturally in the course of a coding project.
Learning to read code well and read it fast is a skill. Largely, this proficiency is influenced by experience and the mastery of utilising a code editor's excellent code insight and code navigation tools, like IntelliSense in VSCode. Don't underestimate this skill, as being able to read through someone else's code lets you pick up common design patterns and programming paradigms by essentially learning from other people's work with the additional benefit of gaining knowledge of the codebase and the solutions as you understand the code in a better light.
Every beginner programmer experiences coding paralysis at least once. Largely, the cause is rooted from a a lack of knowledge manifested through their uncertainty of how a given piece of code is executed. Simply by sandboxing, simulating and executing the code could we further learn from failure. Hence, it is important to try anything and pursue solutions until we find something that works. In brief, it is crucial to develop an attitude that adheres to failure which is essential in debugging software and improved learning curves when learning a new framework or software.
The enthusiasm to learn promotes tackling problems with zeal and ideating creative solution to said problem. By willingly exploring and experimenting, we become proficient in hacking softwares and programming languages. And, essentially gain keener insight in spotting bugs and utilising a languages odd behaviours as a feature. But, don't go over board and keep the code readable and comprehensible. In programming, a single problem could have numerous solutions. But given that we understand a solution's pros and cons, finding the best solution that best fit the specific-context of a problem comes with experience. Precedingly, accumulation of said experience begins with the initiative to explore other solutions and then understanding the solution's positives and negatives.
We need to dare to venture to new territories and start brand new journeys, by having the motivation to not only start coding projects but to see it through the project's completion. As developers, we are the engineers of building softwares, therefore we need to be able to build applications from the ground up and create a product that is production ready.
Reading and writing documentations is plainly part of the job. So, going through countless pages of manuscripts, instruction manuals, and several distinct coding standards require the patience of a monk. Similarly, when dealing with third-party code or unfamiliar and/or messy code from colleagues, developers often need the fortitude to persist in order to comprehend it. Additionally, we often encounter dependecy issues when working with package managers, so sitting down and taking the time to fix things is a valued quality