Dan Cleary’s Post

I routinely use prompts that are several pages long with GPT4 and assistants for coding. Writing a precise and effective prompt takes time and thought which is why I describe it as coding. I don't like the methodology. "Therefore, we use a 0 50 100 150 200 250 Prompt Length (# Words) (a) Density plot of the number of words in HumanEval’s prompts CodeGen-16B InCoder-1.3B GPT-3.5 GPT-4 SantaCoder StarCoder 0 50 100 150 200 Prompt Length (# Tokens) Pass Fail (b) Distribution of passed/failed tasks’ prompt length Figure 6: Distribution of prompt length prompt’s length (i.e., the number of words) as a proxy metric for task complexity. It is a pragmatic choice but we acknowledge its limitation" What they are saying is interesting, but their 100% failure rate at that size is purely a result of the methodology and a lack of prompt quality.

🚀 Day 21/100 of My #100DaysOfCode Challenge 🚀 Today, I explored the fundamentals of Data Structures by implementing a Singly Linked List in C++! 💻 What I Built: A program that demonstrates the core operations of a singly linked list: ✅ Adding nodes dynamically at the end. ✅ Displaying the entire list. ✅ Deleting nodes by value with robust handling for edge cases. ✅ Cleaning up memory efficiently with a destructor. ✨ Key Features: 🔹 Dynamic Memory Allocation: Leveraging pointers for creating and managing nodes. 🔹 Interactive Deletion: Handles scenarios like deleting the head node or a non-existent value. 🔹 Clean Design: Modular functions for appending, displaying, and deleting nodes, making the code reusable and easy to understand. Here’s a quick overview of the Linked List in action: 1️⃣ Start with an empty list. 2️⃣ Add nodes dynamically (e.g., 10 -> 20 -> 30 -> 40). 3️⃣ Delete a node (e.g., remove 20). 4️⃣ Observe the updated list (e.g., 10 -> 30 -> 40). ✨ Why Linked Lists? Working with linked lists deepens understanding of pointers, dynamic memory management, and algorithmic thinking. These skills form the foundation for more complex data structures like stacks, queues, and graphs. 💬 What’s your favorite data structure and why? I’d love to hear how you approach such problems! Let’s connect and share ideas. 🌟 #100DaysOfCode #CPP #DataStructures #LinkedLists #DeveloperJourney #KeepLearning

🚀 Introducing Commi: AI-Powered Git Commit Messages! 🚀 I’m excited to announce the release of Commi – a simple tool that helps you generate meaningful Git commit messages using AI. 🎉 💡 Why Commi? - Save time and effort by automating commit message creation. - Uses AI to generate concise, relevant messages based on your Git diffs. - Easy to set up and works directly with your Git repo. 🔗 Commi on GitHub https://lnkd.in/dNZZneRQ #Git #AI #DeveloperTools #OpenSource #Productivity #Python

Meet the infamous book, the archenemy of the knowledge worker. Yeah, we have fallen this low. Folks in software product development now claim that books are useless, or even counterproductive. It's all over-engineering to sell more books. Better learn this.js and that.js. You can become a senior engineer straight after a bootcamp. AI will replace SQL soon enough, and you'll use prompts to retrieve data. Why will you even need a database, ask the AI to produce the right answer directly. People with 3 years of experience discounting Uncle Bob and making fun of things like decoupling in public. How could we allow this to happen? How much did we sacrifice on the altar of political correctness? When did we stop telling people what's what just for the sake of not hurting their feelings?

While Spring provides a wide range of built-in annotations, some scenarios call for custom annotations to address unique use cases. By creating custom annotations, you can streamline repetitive tasks, enhance code readability, and improve reusability across your application. When creating your own custom annotation, you need to use the following annotations: - @𝐑𝐞𝐭𝐞𝐧𝐭𝐢𝐨𝐧: Specifies how long the annotation should be retained, either at runtime or source level. - @𝐓𝐚𝐫𝐠𝐞𝐭: Defines where the annotation can be applied, such as methods, fields, or classes. - @𝐃𝐨𝐜𝐮𝐦𝐞𝐧𝐭𝐞𝐝: Ensures that the annotation is included in the generated Javadoc. Read more about 𝐂𝐫𝐞𝐚𝐭𝐢𝐧𝐠 𝐂𝐮𝐬𝐭𝐨𝐦 𝐀𝐧𝐧𝐨𝐭𝐚𝐭𝐢𝐨𝐧𝐬 𝐢𝐧 𝐒𝐩𝐫𝐢𝐧𝐠 my latest article 💡 https://lnkd.in/eDm3-XtP

Enhancing Code Quality: Practical Solutions for Code Smells (part1) As I continue my exploration into code smells, it’s crucial not only to identify but also to effectively address these common issues. In this post, I want to write a few things that I've learned from my studies. - Long Method: Combat this with the "Extract Method" technique to break down bulky methods into smaller, manageable pieces. - Large Class: Use strategies like "Extract Class," "Extract Subclass," and "Extract Interface" to simplify large classes and enhance maintainability. - Primitive Obsession: Transition from simple data types to objects with "Replace Data Value with Object," improving data handling and flexibility. - Data Clump: Consolidate frequently grouped variables into classes using "Introduce Parameter Object," enhancing structure and reusability. Each of these solutions not only solves the immediate problem but also improves the overall architecture of your applications. As I delve deeper into "Dive Into Refactoring" by Alexander Shvets, I’ll share more sophisticated techniques and insights. #code_quality #software_development #smell_code

🚀 Offset vs Cursor Pagination: Which One is Right for Your Backend? 🔍 As a backend developer, efficient data retrieval is key, especially when handling large datasets. In my latest article, I break down two essential pagination strategies: Offset and Cursor Pagination. 🧐 I dive into: 🛠️ The mechanics behind Offset Pagination ✨ The efficiency of Cursor Pagination for large datasets 🧩 How to choose the right strategy based on your application's needs 💡 Whether you're optimizing your backend or scaling your system, understanding these techniques is crucial. 👉 Read the full article here: https://lnkd.in/gvBQEKyZ #softwaredevelopment #backend #bestpractices

Bytes of Best Practices: Commit Clean Code, Every Time Welcome to the second post in my Bytes of Best Practices series! In early days of my career, One time I spent an entire day fixing a production issue caused by messy SQL code and ineffective code review that resulted incorrect statement and caused huge escalation!!. A task that should’ve taken minutes turned into a nightmare, all because of poorly formatted, unreadable code. That experience taught me a valuable lesson: clean code isn’t optional, it’s essential. Here’s how you can establish the habit of committing clean code: 1. Follow Code Conventions: Use your organization’s standards as a foundation for consistent style and structure. 2. Leverage Plugins: Tools like Prettier, ESLint, and Poor Man’s T-SQL Formatters ensure your code meets conventions automatically. 3. Automate Code Reviews: Integrate these tools into your commit process using CI/CD pipelines to catch issues before they hit production. Why it matters: Reduces time spent debugging messy code. Improves team collaboration with readable, maintainable code. Enhances work-life balance by minimizing weekend production fire drills. Here's an example where on left you can see horizontal spacing is used and uneven letter casing making it hard to read even though there is nothing complex here, imagine there is a bug in here and you have to triage it on production priority calls. Right?? Imagine having tools that automatically align your code to best practices every time you commit, saving hours and ensuring peace of mind. How do you ensure your commits are clean and error-free? Let’s discuss in the comments!

🐍 Well, Flask is great. I wrote about writing code with Flask yesterday and i just felt something: - Its the best framework to jump on, especially if you want things done quickly. - Its SUPER EASY to use and implement a small project that does not need any fancy scalability requirements. The only negative point (for me) is: - Lacks support and documentation. Im not sure if im too sloppy but i find myself in need for blog posts every time i need to implement some specific functionality. One thing i can tell for sure: - If you have some patience, you might be able to escalate a Flask application to a fully-production environment to handle a thousand requests a day.

We talk about making source code readable and it turns out that this isn’t just stylistic interpretation; there is actual research into this topic. As we read through the code, what we’re scanning for are chunks and beacons. Chunks and beacons are similar in that they’re both code fragments, yet they’re used differently. “Chunks are described as code fragments in programs. Available literature shows Chunks to be used during the bottom-up approach of software comprehension. Chunks vary in size. Several Chunks can be combined into larger Chunks.” A looping structure could be a chunk, contained inside a method which is also a chunk, contained inside a class which is also a chunk. You’ve probably heard that our working memory can retain 7±2 (5-9) chunks of information at any one time. Our ability to chunk the source code allows us to retain more of the concepts in working memory at once. Experts are able to chunk more effectively than novices based on patterns that they’ve become familiar with. Even novices can benefit from structural chunking, however. “Beacons are code fragments that help developers comprehend programs. It has been shown that expert programmers pay more attention to Beacons than novices.” Beacons are often used to confirm hypotheses about the code. We start with a general hypothesis about what the code does, from documentation or conversation or perhaps naming. We then look to these beacons to confirm our understanding of this. Do we find the things that our hypothesis would expect us to find? If looking at a specific part of the code confirmed something you were thinking, that was a beacon. Beacons make it easier to chunk the code as they draw our attention. When reading through the code, an expert will recall the beacons far more easily than the non-beacons. Novices and intermediates will recall the non-beacons better, presumably because they were scanning line by line. When programmers know that specific design patterns are present in the code then those patterns become useful beacons. These don’t have to be named patterns that we would find in a catalog; they could be a swap operation in a sorting algorithm. Names in the code are important beacons. Ensuring that we have good variable names, will allow an expert to scan the code more effectively. For a version of this post that has links to research, see the first comment.