Programming Achievements: How to Level Up as a Developer [jasonrudolph.com] Published on Tuesday, August 09, 2011 in better How does a good developer become a great developer? Forget greatness for a moment: How does a decent developer become a good developer? There is no definitive path from Step 1 to Step n. Heck, it's not even clear what Step n is. And as logically-minded developer types, the lack of a well-defined route can make for a daunting journey from novice to master. I've spent a fair bit of time over the last few years bumping up against this conundrum. What Does Success Look Like? I do my best work when I have a goal with clear, measurable criteria for success. But how do you measure whether you've attained the rank of "really good developer?" Much like the goal of wanting to run a 5-minute mile, we can start by looking at where we are as a programmer versus where we want to be. We've all had specific experiences that clearly advanced our skills as developers. And what better way to get started with Step 1 than to crowdsource it? Achievements Notes
PHP Master | The Single Responsibility Principle Robust software systems should be built up from a web of interrelated objects whose responsibilities are tight, neatly cohesive, boiled down to just performing a few narrowed and well-defined tasks. However, it’s admittedly pretty difficult to design such systems, at least in the first take. Most of the time we tend to group tasks in question by following an ad-hoc semantic sense in consonance with the nature of our own human mind. One of the most notorious consequences of this rational associative process is that, at some point, we effectively end up creating classes that do too much. The so-called “God class” is quite possibly the most extreme and coarse example of a structure that packages literally piles of unrelated operations behind the fence of the same API, but there are other subtle, more furtive situations where assigning of multiple roles to the same class are harder to track down. A good example of this is the Singleton. Putting Data Access Logic in a Data Mapper
untitled ------------------------------------------- T h e T a o O f P r o g r a m m i n g ------------------------------------------- T r a n s l a t e d B y G e o f f r e y J a m e s - 1 - --------------------------------- T a b l e o f C o n t e n t s --------------------------------- Book 1 -- The Silent Void Book 2 -- The Ancient Masters Book 3 -- Design Book 4 -- Coding Book 5 -- Maintenance Book 6 -- Management Book 7 -- Corporate Wisdom Book 8 -- Hardware and Software Book 9 -- Epilogue - 2 - T h e S i l e n t V o i d B o o k O n e ----------------------------------------------------------------------- Thus spake the master programmer: "When you have learned to snatch the error code from the trap frame, it will be time for you to leave." ---------------------------------------------------------------------- 1.1 Something mysterious is formed, born in the silent void. Waiting alone and unmoving, it is at once still and yet in constant motion. It is the source of all programs.
Programming Optimization: Techniques, examples and discussion In the old days, it was pretty easy to understand that writing your programs in assembly would tend to yield higher performing results than writing in higher level languages. Compilers had solved the problem of "optimization" in too general and simplistic a way, and had no hope of competing with the sly human assembly coder. These days the story is slightly different. Compilers have gotten better and the CPUs have gotten harder to optimize for. Inside some research organizations the general consensus is that compilers could do at least as well as humans in almost all cases. But have compilers really gotten so good that humans cannot compete? On a Pentium, it is ordinarily beneficial to declare your data so that its usage on inner loops retains as much as possible in the cache for as long as possible. The pentium also has an auxiliary floating point execution unit which can actually perform floating point operations concurrently with integer computations.
The Tao Of Programming Translated by Geoffrey James Transcribed by Duke Hillard Transmitted by Anupam Trivedi, Sajitha Tampi, and Meghshyam Jagannath Re-html-ized and edited by Kragen Sittler Last modified 1996-04-10 or earlier Table of Contents Book 1 - The Silent Void Thus spake the master programmer: ``When you have learned to snatch the error code from the trap frame, it will be time for you to leave.'' Something mysterious is formed, born in the silent void. If the Tao is great, then the operating system is great. The Tao of Programming flows far away and returns on the wind of morning. The Tao gave birth to machine language. The assembler gave birth to the compiler. Each language has its purpose, however humble. But do not program in COBOL if you can avoid it. In the beginning was the Tao. Programmers that do not comprehend the Tao are always running out of time and space for their programs. How could it be otherwise? The wise programmer is told about Tao and follows it. The highest sounds are hardest to hear.
PHP Master | Managing Class Dependencies: An Introduction to Dependency Injection, Service Locators, and Factories, Part 1 Let’s face it: for good or bad, OOP has been actively drilling deep holes in the soil of PHP in the last few years, hence its ubiquitous presence now is anything but breaking news. Furthermore, while this steady incremental “objectification” in the language’s terrain is generally considered a beneficial shift towards new and more promising horizons, for those still rooted in the procedural paradigm, the process has been far from innocuous. There’s a few solid arguments that sustain this mindset: first and foremost the nature of OOP is awkward and inherently complex, plagued with nuance that can take literally years to tame. Also, defining the APIs that OO components use for interacting with one another can be quite a burden at times, especially when it comes to designing systems whose backbone rests on facilities provided by large and tangled object graphs. Evidently, the topic is a world away from being banal, and as such it deserves a close, in-depth analysis. Closing Remarks
Dijkstra Archive: A Short Introduction to the Art of Programming (EWD 316), Chapter 9 9. The problem of eight queens The problem is to make a program generating all configurations of eight queens on a chess board of 8 * 8 squares, such that no queen can take any of the others. We don't have an operator generating all these configurations: this operator is exactly what we have to make. With the aid of the generator (3) for the elements of set B, the elements of set B can then be generated in turn; they will be subjected to the decision criterion (2) which decides whether they have to be skipped or handed over, thus generating elements of set A. Three remarks are in order. 1) If the whole approach makes sense, set B is not identical to set A and as it must contain set A as a (true) subset, it must be larger. Above we have sketched a very general approach, applicable to many, very different problems, Faced with a particular problem, i.e. faced with a specific set A, the problem is of course, what to select for our set B. Note. But now we have found set B! Where version 1 has
Robust Programming Department of Computer Science University of California at Davis Davis, CA 95616-8562 Principles of Robust Programming A robust program differs from a non-robust, or fragile, program by its adherence to the following four principles: Paranoia. Don't trust anything you don't generate! Stupidity. Part of the problem is that in a week, you most likely will have forgotten the details of your program, and may call it incorrectly or give it bogus input. Dangerous Implements. Hiding data structures also makes your program or library more modular. Can't happen. Exercise 1. Robust programming is defensive, and the defensive nature protects the program not only from those who use your routine but also from yourself. Example of a Fragile Library This library implements queues in a very straightforward way. The library can handle any number of queues, and when a queue is created, its pointer is returned to the caller. The Queue Structure The header file contains: qptr->count = newvalue; Exercise 2. and
New programming slang - Programming A question recently posted on stackoverflow.com asked for people to submit programming terms that they or their team have coined and have come into regular use in their own circles. Below are the most popular answers Yoda Conditions The act of using if (constant == variable) instead of natural if (variable == constant),; for example, if (4 == foo). Because it is like "if it is the blue – this is the sky" or "if that is tall – this is a man." Pokémon Exception Handling When you catch all the exceptions and then you try somehow to analyze them. try{ //code }catch ( Exception ex){ if( ex instanceof SubException){ //code }else if(ex instanceof SubSubException){ //code }else{ //code } } Discuss an example here Egyptian brackets This is the style of brackets, when an opening bracket is placed at the end of this line: if (a == b) { printf("hello"); } Why do we call this style "Egyptian brackets?" Different types of bug reports Stringly Typed It is a riff on strongly-typed. Other types of errors
Table Oriented Programming A practical, intuitive, and consistent way to organize and process data and algorithm collections Updated 2/12/2002 Summary of Primary Table-Oriented-Programming Concepts Control Tables - A way of organizing processing, decision, and attribute logic. Table-Friendly Syntax - Syntax and language constructs that make dealing with tables and T.O.P. easier and more natural. This includes overcoming the weaknesses of SQL. Data Dictionaries - Special Control Tables for storing processing, decision, and attribute logic for relational database fields and/or UI fields. Table-Oriented Programming (TOP for short) can be characterized as a programming language and/or development method that makes dealing with tables, lists, indexing, sorting, searching, filtering, etc. a native and direct part of language design and complexity management. Most general-purpose languages use API-like constructs (function library calls) and SQL to deal with tables. a = (b * c) + e + f Or, in OOP-ish syntax: