Tasnuva Islam Mila’s Post

Register : It is a some data type. => It hints the compiler to store a variable in register memory. => This is done because access time reduces greatly for most frequently referred variables. => This is the choice of compiler whether it puts the given variable in register or not. => Usually compiler themselves do the necessary optimizations. Function: A function is a block of code which only runs when it is called. Scanf function : Accept character, string and numeric data from the user using standard input- keyboard. (&) = address of operator Operators : operators are symbols that represent operations to be performed on one or more operands. Some of them are : 1. Arithmetic Operator. 2. Increment/Decrement Operator. 3. Relational Operators. 4. Logical Operators. 5. Bitwise Operators. 6. Assignment Operators. 7.Other Operators.

Rather pleased to have coded a feature (command line option "-v", as I've replaced the former "v" for "verify Mantel" with a capital "M": "v" being the "verbosityfeature"; it peruses the workspace items and tells each of them to output themselves to the given stream (such as std::cout). Also -v takes a numeric argument which is a simple prime number encoding of many levels of verbosity, e.g. "hey flagcalc, run a isomorphism count and print out just the number of isomorphisms, omitting the full listing". Yes, this is a good use of C++ features. Now the timer, also, is of just the run time minus the time to stream the output. So testbip12.dat takes 19.4 seconds instead of 37.9. Bear with me as I track down a memory problem; for now the code doesn't do the "list fingerprint" thing, since that is causing a crash; it does still announce if the fingerprints match. Also do not use the compiler defines "USETHREAD" , "USETHREADPOOL", etc.: that code, some compiling and some not, runs in equal time to the define NOTTHREADED variant (all these in graphs.cpp top of file). So this is a beta release, and will be uploaded within the hour.

⚙️ Understanding Go Slices vs. C Dynamic Arrays In Go, slices are a high-level abstraction over arrays, offering more flexibility and ease of use compared to dynamic arrays in C, which require manual memory management. Here's a comparison between Go slices and dynamic arrays in C: 1. Memory Management: - Go Slices: Memory management is automatic. When a slice grows beyond its capacity, Go automatically allocates a larger underlying array and moves data to it. Developers don't need to worry about allocating or freeing memory. - C Dynamic Arrays: You must manually manage memory using functions like `malloc()` and `realloc()`. If you don’t manage it correctly, this can lead to memory leaks or crashes due to improper allocation or deallocation. 2. Ease of Use: - Go Slices: Slices come with built-in functions such as `append()`, which seamlessly expands the slice. You also have `len()` and `cap()` to get the length and capacity, making operations straightforward. - C Dynamic Arrays: You have to manually resize arrays with `realloc()`. Keeping track of the current size and capacity is also up to the developer, which adds complexity and can lead to errors. 3. Safety - Go Slices: Go has runtime bounds checking, which prevents out-of-bounds access, improving safety and reducing potential bugs. - C Dynamic Arrays: Accessing memory outside the bounds of the array can lead to undefined behavior, and the compiler or runtime does not enforce bounds checking. 4. Performance: - Go Slices: While Go abstracts away manual memory management, slices are still efficient. However, when slices grow, the internal resizing can cause temporary performance hits. - C Dynamic Arrays: Dynamic arrays in C can be more performant in certain low-level cases since they give developers full control over memory allocation. However, this requires more effort to optimize. Conclusion: Go slices provide a simpler, safer, and more user-friendly way to handle dynamic collections of data, automating much of the complexity involved in resizing and memory management. On the other hand, C’s dynamic arrays offer more control but at the cost of increased complexity and risk of errors.

Came across something interesting while working with binary numbers in C++: What do you see on the screen as a result of the following statements? cout << 0b100 << 1 << endl; cout << (0b100 << 1) << endl; Answer: 41 8 Why? The "<<" operator of the cout stream is the same as a left bit shift operator for a binary number. 0b100 is 100 in base 2 which is 4 in base 10. (0b100 << 1) shifts the bits to the left, which leads to 1000 (8 in base 10). Shifting a bit to the left always doubles the number. Shifting a bit to the right always halves it. When you don't use the parenthesis, the bit shift is not executed first, and the compiler interprets it as if you simply want to display 0b100 followed by 1. Hence, you see the number 41.

Day 0x02 🌱 Went over Chapter 1 (Already familiar with most of the concepts presented). Topics covered: The Static allocation, stack, pointers, heaps, manual & automatic memory management(Allocator, Mutator & Collector), Approaches to automatic memory management eg Reference counting & Tracking collector. The stack machine is a very important concept to how modern day languages like .NET run code. Using the stack machine enables designing platform independent VMs eg. JVM, .NET Runtime. Pointers are deadly, pointers allow us build complex data structures. Heap: The heap is an area of memory used for dynamically allocated objects. Some comparisons between the stack and heap(Picture below). Manual Memory Management: "With great power comes great responsibility". The developer is solely responsible for allocating and deallocating memory. Memory leaks can happen, errors due to dereferencing a NULL pointer, casting can be error prone etc Manual memory management can be cumbersome, Automatic memory management to the rescue. The process is called Garbage Collection. 🛠 Happy Learning!! ✔ #100daysoflearning #softwareengineering #dotnet 🚀

I used to think Big O notation was the ultimate measure of code efficiency. I was wrong. Big O is a starting point, but true efficiency depends on many other factors: 1. Hidden Costs in Data Structures and Algorithms 📈   - For example, adding an element to an ArrayList and LinkedList both take average O(1) time. However, when an ArrayList reaches its capacity, resizing adds an extra O(n) time complexity. 2. Real-World Hardware and System Constraints  💾   - Big O doesn’t account for hardware specifics like CPU cache, memory latency, or disk I/O. Algorithms with the same Big O complexity can perform differently based on how well they interact with hardware—especially in memory access patterns that either help or reduce CPU cache performance. 3. Parallelism and Concurrency  🔀   - Big O assumes a single-threaded context and doesn’t consider the potential gains from parallelism. An O(n) algorithm running across multiple threads can be significantly faster than a single-threaded O(n log n) algorithm, depending on processor count and task management overhead. 4. Constant Factors and Lower-Order Terms 1️⃣   - Big O ignores constants and lower-order terms, but these can be crucial. For instance, an O(n) algorithm with a large constant factor may be slower than an O(n log n) algorithm for smaller input sizes. Key Takeaways: 💡 Big O is an important factor to understand the code efficiency, but not the only factor.

#thoughtoftheday - 155- 03/06/2024 About Complexity of algorithm: •Time complexity : •The time needed by an algorithm expressed as a function of the size of a problem is called the time complexity of the algorithm. •The time complexity of a program is the amount of computer time it needs to run to completion. • The limiting behavior of the complexity as size increases is called the asymptotic time complexity. It is the asymptotic complexity of an algorithm, which ultimately determines the size of problems that can be solved by the algorithm. •Space complexity : •The space complexity of a program is the amount of memory it needs to run to completion. • The space need by a program has the following components: • Instruction space: Instruction space is the space needed to store the compiled version of the program instructions. •The amount of instructions space that is needed depends on factors such as: The compiler used to complete the program into machine code. The compiler options in effect at the time of compilation The target computer. •Data space: Data space is the space needed to store all constant and variable values. • Data space has two components: Space needed by constants and simple variables in program. Space needed by dynamically allocated objects such as arrays and class instances #thanks

Understanding Escape Analysis in Go https://lnkd.in/dxcX7DZj Go uses escape analysis to determine the dynamic scope of Go values. Typically, go tries to store all the Go values in the function stack frame. The go compiler can predetermine which memory needs to be freed and emits machine instructions to clean it up. This way it becomes easy to clean up memory without the intervention of the Go Garbage Collector. This way of allocating memory is typically called stack allocation. But when the compiler cannot determine the lifetime of a Go value it escapes to the heap. A value may also escape to the heap when the compiler does not know the size of the variable, or it’s too large to fit into the stack, or if the compiler cannot determine whether the variable is used after the function ends or the function stack frame is not used anymore.

In this post I show what the compiler generates when you use collection expressions with the spread element and how it depends on the collections used

What Happen When We Exceed Valid Range of Built-in Data Types in C? Signed Integers (signed int) Signed integers can hold both positive and negative values. The range of a signed int typically depends on the compiler and the system architecture, but it is commonly from -2,147,483,648 to 2,147,483,647 (assuming 32-bit int). Exceeding the Upper Limit: If you exceed the maximum positive value (INT_MAX), the behavior is undefined. This means the compiler or runtime environment may handle it in unexpected ways. It could wrap around (become negative), crash the program, or produce incorrect results. Exceeding the Lower Limit: Similarly, if you go below the minimum negative value (INT_MIN), the behavior is undefined. It could wrap around (become positive), crash the program, or produce incorrect results. Unsigned Integers (unsigned int) Unsigned integers can only represent non-negative values (including zero). The range of an unsigned int is typically from 0 to 4,294,967,295 (assuming 32-bit unsigned int).  Exceeding the Upper Limit: If you exceed the maximum value (UINT_MAX), the behavior wraps around. This means the value will start again from zero and continue counting up. For example, UINT_MAX + 1 results in 0.  Exceeding Zero: Unsigned integers cannot represent negative values. If you attempt to assign a negative value or perform operations that result in a negative value (like subtracting a larger number from a smaller one), the result is still well-defined within the modulus of UINT_MAX + 1.