IEEE Women in Engineering ’s Post

Importance of C Language • C is called as a robust language, which has so many built-in functions and operations, which can be used to write any complex program. • Generally, we use to call C as a middle level language. Because, the ‘C’ compiler combines the capabilities of an assembly language with the features of a high-level language. Therefore, it is best for writing both system software and business packages. • ‘C’ Programs are efficient and fast. • C is highly portable, that is, ‘C’ programs written on one computer can be run on another with little (or) no modification. • ‘C’ language is best for structured programming, where the user can think of a problem in terms of function modules (or) blocks. • It has the ability to extend itself. It was named ‘C’ because it is an offspring of BCPL (Basic Combined Programming Language) which was popularly called ‘B’ language. #snsinstitutions #snsdesignthinkers #designthinking

GCC Compilation in Simple Steps Introduction: In this blog post, we'll explore how GCC (GNU Compiler Collection) transforms source code into executable programs, breaking it down into four main steps. What is GCC? GCC, or GNU Compiler Collection, is a widely-used compiler for C and C++ languages, making code understandable for computers. The Compilation Process: Step 1: Preprocessing: The preprocessor prepares code for compilation by handling things like #include and #define directives. It simplifies code for the compiler. To do this, use: gcc -E main.c -o main.i Step 2: Compilation: The compiler translates C code into assembly language. It generates an assembly file. To compile, use: gcc -S main.i -o main.s Step 3: Assembly: The assembler turns assembly code into machine code, creating an object file. Assemble with: gcc -c main.s -o main.o Step 4: Linking: The linker combines object files and resolves dependencies to create the final executable. Link like this: gcc main.o -o my_program Conclusion: Understanding GCC's compilation process, which involves preprocessing, compilation, assembly, and linking, is fundamental for effective programming. It helps you troubleshoot and optimize your code.

Rust adds diagnostic attributes for compiler messages https://trib.al/qCjD98I

Rust adds diagnostic attribute namespace for compiler messages https://trib.al/3GBuc1s

C# compiler: Reflection and Code Generation Data Annotation techniques are a relatively new feature in C#, first introduced in C# 3.0. They are implemented using a combination of "Reflection and Code Generation". - Reflection is a programming technique that allows a program to inspect and modify its own code. In the context of the C# compiler, reflection allows the compiler to inspect the code elements that data annotations are applied to. This allows the compiler to gather information about the code elements, such as their type, name, and other attributes. - Code generation is a programming technique that allows a program to generate code dynamically. In the context of the C# compiler, code generation allows the compiler to generate code that implements the data annotations that are applied to code elements.

--Inline functions in C language -- An inline function is a programming construct that suggests to the compiler to expand the code of the function at the point where it's called, rather than executing a function call(Context switching needed). This means that instead of having a separate function call with its own function prologue and epilogue, the code of the inline function is inserted directly into the calling code. * In an inline function, a function call is replaced by the actual program code. * Most of the inline functions are used for small computations, they are not suitable for large computing. * The code size will increase because of the Substitution for the code. * The execution time will decrease because of there is no executing function call (Context switching). But How can we create an inline function ? An inline function is similar to a normal function in the syntax, but the only difference is that we place a Keyword "Inline" before the function name in case if you are using C99, But if you are using ANSI write "__inline". #embeddedsystems

Today's language is the awesome "C", created by the legendary Dennis Ritchie at Bell Labs. Very highly efficient, compiled, with a static type system, and designed to very efficiently map to machine language, designed for portability across CPUs with a minimal runtime. It relied on the programmer to manage memory allocation and release. Because of portability and small footprint, it is commonly used in embedded systems programming. It had elegant support for references including pointers to functions, how arrays worked, and parameters that could be value/reference.   I first used Lattice-C in the early 1980s and taught myself using only he small elegant K&R as a language reference. C was developed in parallel with Unix by Ritchie and Ken Thompson, starting from "B" and NB (New B) both of which I've never touched.   The K&R introduced the I/O library and was the singular reference for C. Of course C# and C++ greatly extended C with Object Orientation, a number of incremental variants started from ANSI C, C99, C11, C17, C23 and Embedded C. Java's roots are clearly C as well.   There's a primitive simplistic beauty to the original C that entrusted the developer to manage references, pointers, array bounds and release memory with no runtime oversight whatsoever. Reality is, sloppy programming was fatal, with easy memory leaks and overwrites, and heap and stack corruption.   #include <stdio.h> int main() {   // printf() displays the string inside quotation   printf("Hello, World!");   return 0; }

It's important to Familiarize Yourself with Computer Architecture and Data Basics One of the wonderful things about modern programming languages is that they enable us to create fancy applications without worrying about the nitty-gritty details of the hardware behind the scenes (for the most part).

Multithreading in Modern C++ With the new C++11 Standard, C++ faces the first time challenges of multicore architectures. The 2011 published standard defines how a C++ program has to behave in the presence of multiple threads. The C++11 multithreading capabilities are composed of two components. This is, on the one hand, the defined memory model, which is on the other hand, the standardized threading interface. A well-defined memory model The defined memory model is the necessary basis so that multithreaded programming makes sense in C++. Thus, the memory model has to give answers to the following questions. What are atomic operations? Which order of operations is ensured? When are the memory effects of operations visible? To 1: Atomic operations are operations that follow the first three letters of the famous ACID Idioms from the database theory. Atomic operations are atomic (A), going from one consistent (C) state to the next and are executed in isolation (I). This means in particular, no other thread can observe an intermediate state of an atomic operation. The incrementation atomVar++ shows the consistency and isolation of an atomic operation very nice. If atomVar is an atomic variable, atomVar can have only the old or the new value. The consistency of the variable atomVar is, that it changes only from one state to the other and the isolation, that another thread can not observe any intermediate value. To 2: Both the compiler that translates the program into assembler instructions and the processor that executes the assembler instructions, can rearrange the operations. Most often this is for performance reasons. In addition the various tiers of storage (cache) posse the possibility to provide the result of the operations in a delayed way. To 3: Since it is quite possible that one thread sees an operation on a variable later than another, the threads have to obey certain rules. #xntricservices #itstaffing #technicalrecruitment #qualityservices

I like the graph--I think it's an accurate portrayal of my own career, and that of many others I've known (and respected). BTW, "architect" goes on here somewhere, too. Probably somewhere between Tech Lead and Engineering Manager. But I also think the graph makes a fatal mistake, in assuming that "technical skill" is a linear number--I have a friend who knows more about tweaking the JVM than I do, yet I know more about how virtual machine design and how others are constructed in general than he does. Which of us is higher than the other on that Y axis?