- They finally found all those buried Atari cartridges, and confirmed a beloved urban legend. Just wonderful.
- This episode of @ExtraCreditz follows up an idea I always had about education. The key is being demanding, but allowing a lot of opportunities.
- Amazing book introduction, showing how no one is immune to think that they are stupid. Lots of things in live are hard.
- Readability in code is not about being literary. Is about making the code easy to understand. You don’t read code, you explore it.
- The Great Works of Software. The premise is extremely interesting. What are the most influential pieces of software?
- The hilarious (is funny because it’s true) Programming Sucks and a follow-up What programming is Like.
- Is programming a dead end job? I still can’t help but feel sad each time that a (good) developer decides to move into management.
- It’s easy to forget how much the things have changed in term of software distribution. What Writing and Selling Software Was Like in the 80′s (yep, also from The Codist. You should subscribe)
- The computer world is very dominated by English, and even so with latin alphabet. This idea about making a computer language in Arabic is fascinating. It not only shows how difficult is to set up an environment without problems out of “the ASCII world” (the magnitude is not comparable, but trying to code in languages like French or Spanish has a lot of friction), but it also shows up how alien (yet beautiful) a different alphabet looks. I wonder how code and programming will be if the dominant language would’ve been something like Chinese or Arabic.
- What is the “Agile mindset” anyway? The graph is very interesting. Specially the “Chaos labeled as Agile” side.
- I don’t really like the idea of “rivalry” against Vim and Emacs. I prefer to consider them two valid options. But this article goes into explaining their different appeals and why they have been around since an extremely long time ago in computer-years.
- 10 Most common Python mistakes. Good to check.
I saw yesterday live the Apple keynote on the WWDC. I am far from an Apple developer, but I use OS X and iOS everyday, and I’m interested on new stuff. There was a full section devoted to developers, which is great (well, it’s supposed to be a developer’s conference, after all), and, arguably, the most interesting stuff on that part (for a developer’s perspective) was the release of a new programming language, Swift.
It was announced with an (irrelevant) comparison with Python in terms of speed (I actually have plans to write a post about “why Python is not really slow“, but I digress), as well as a lot of other details that (IMO) are completely pointless in terms of what makes a good or bad programming language.
I am generally skeptic about the announcement of new languages. Almost as much as new web frameworks. Sure, it adds a new flavour, but I’m not that sure about real advancement in tech. Creating a new language, full with proper “clean and beautiful” syntax is not really that difficult. The difficult part is to create a vibrant community behind it, one that loves the language and works to expand it, to push the boundaries of current tech, to make amazing applications and tools, to convince other developers to use it and to carry on the torch. The target of a language are developers. “End customers” couldn’t care less about how the guts of their products are done. “Ruby sharp? Whatever, I just need that it help us increase our sales“
Interestingly enough, languages get a lot of character from their communities, as they embed their values on the relevant modules and tools. A great example of that is “The Zen Of Python“. There’s nothing there about whitespaces, list comprehensions or classes, but it reflects a lot of the ideas that are common on the Python world, values of the Python Community. Using a language is not just writing code, but also interacting with other developers, directly or even just reading the documents and using the APIs.
Obviously, Apple is a very special situation, as it can force developers to use whatever they like for their platform. Hey, they managed to create an Objective-C ecosystem out from nowhere, which is impressive. For what is worth, they can even tailor a language for their platform, and not to worry about anything else. iOS is a platform big enough for devs to have to learn the language and official IDE and use it. And I am pretty sure that in this case it will be an improvement over the previous environment.
But the one part that I am most skeptic about is the “visual programming” stuff. One of the “wow” announcements was the possibility of creating “playgrounds”, to show interactively the results of the code. That means that, for example, a loaded image will be available, or that a graph can be displayed showing the results of a function. And that’s the part that I’m not really that sure that is interesting or relevant at all.
Does it look cool? Absolutely. May it be interesting once in a while? Sure. But I think that’s the kind of process that, in day to day operation, is not really that useful in most kinds of programming.
Programming, more than anything else, is creating a mental image of code. Code can be a very complex thing. Especially on a big application. But normally we don’t need to keep the whole code in our mind. We only have to keep certain parts of it, allowing to focus in a problem at a time. That’s the main principle behind modules, classes and other abstractions. I can use OS calls to open a file, to draw some pixels on the screen, or to make a call to a remote server. All of that without having to worry about file systems, graphic drivers or network protocols. And I can also use higher level modules to search on files, create 3d models or make HTTPS calls.
And the amazing power of programming is that you are coding on the shoulders of giants. And on the shoulders of regular people. And on the shoulders of your co-workers. And on your own shoulders. That’s a lot of shoulders combined.
But a lot of that process deals with the unavoidable complexity of the interaction. And being able to move from an abstracted view to a more specific one, to look inside and outside the black box, is crucial. It may not be evident, but the mental process of programming deals a lot with that sudden change in perspective. This is one of the reasons of multiparadigm being a useful thing. Because you can move between different abstractions and levels, using the proper one on each case (especially for leaky ones).
And there are lots of those processes that are not easily represented with graphs or images. They are constructs on your mind: loops, flexible structures, intuitions on the weak points of an algorithm, variables changing values, corner cases… Showing all intermediate results may be detrimental to that quick change in perspective. Too much information.
There has been experiments with visual programming, trying to represent code as visual blocks in one way or another, since a long time ago (at least 25 years). They are useful in certain areas, but they are far from a general solution. There are also interactive notepads to allow easy display of graphs and help with the interactivity. iPython Notebook is an excellent example (and a very similar idea to the playground). But, again, I feel that those are specialised tools, not something that is that useful in most programming contexts.
I’m just skeptic. All of this doesn’t necessarily means that Swift is bad, or that those tools are wrong. Maybe the new X-Code will have a lot of amazing tools that will help create fantastic applications (I still don’t like IDEs, though). There are already people checking the docs and giving a try to the new language. But I think that it has to show up how good or bad it is for itself, and by the developers that decide to use it. So far, it is just an announcement. I just feel that most that was said on the keynote was not relevant to determine whether it’s a good working environment or not, but was just a gimmick. Yes, obviously these kind of announcements are publicity stunts, but in this particular case it looks especially so.
Looks cool, but is not particularly relevant to how the mental process of programming works or what makes a language good.
- Seven habits of effective text editing. A great essay by Bram Moolenaar (of Vim fame). It is applicable to any editor, but, of course, shows why Vim can be such a good choice (once you know how to use it, obviously)
- A useful collection of recipes in Python. Thirty python language features and tricks you may not know
- How to be a sane programmer. Basically, do other stuff not related to programming. The related Business Insider article is also worth the read.
- The Evolution of a Software Engineer
- D/A and A/D Digital Show and tell. Great explanation on how sampling and analog conversion works. I spent my college years dealing with this stuff (and using the same equipment), it is explained beautifully.
- 10 important URLs that every single Google user needs to know Interesting stuff about privacy and Google.
- A glass breaking recorded at high speed.
- How to Create an Awesome Candidate Experience. On thing that I particularly liked about it is the fact that it acknowledges how emotionally exhausting is to go through a recruitment process for the candidate.
- Game servers UDP vs TCP. great article about the differences between TCP and UDP, usually not well understood.
- Amazing precision. The art of Street Typography.
- I love this quote: “I do not want to be a “rock star”. I want to be a good engineer on a great engineering team“. I talked previously about this, and how a great team will be much more productive than a bunch of “Ninja Developers”.
One of the things I like most about developing software is the fact that you can recover from most mistakes with very few long term impact.
Bugs are unavoidable, and most of the people involved on programming deeply understands that is something we all live with. So, there’s no hard feelings, once you find a bug, you fix it and immediately move on. Not only no one thinks that you’re a bad developer because you write bugs, but typically the impact of a bug is not that problematic.
Yes, there are some bugs that are just terrible. And there’s always the risk of losing data or do some catastrophic operation on production. But those are comparatively rare, and with the proper practices, the risk and damage can be reduced. Most on the day to day operation involves mistakes that have a much limited effect. Software development is more about being bold and move fast fixing your mess, than it is to play safe (within limits, of course).
Because the greatness of software is that you can break it on purpose and watch it explode, and then fix that problem. In a controlled environment. Without having to worry about permanent effects or high costs. And a good test is the one that ambushes the code and try to viciously stab it with a poisonous dagger. The one that can hurt. So you know that your system is strong enough against that attack. And then iterate. Quickly. It’s like having a permanent second chance to try again.
Not every aspect of live is that forgiving. I guess that a lot of doctors would love to be able to do the same.
- Some gifs showing Vim capabilities. Why I use Vim.
- More about the philosophies behind vim. Why Atom can’t replace vim.
- A browser game, similar to the great Threes for iOS, with a binary twist. 2048 It can be a little addictive, though.
- An this is another brilliant game. Create your own metro system. Mini Metro.
- 3 wrong ways of storing a password and some examples to do it in a more proper way. And more about setting a salted password hashing.
- Don’t be a technical masochist. It is good to have options and recognise best tools for the job.
- An article about the different issues (while mostly stating age on the title) that can be growing on the current “startup culture”. Maybe a little exaggerated in some aspects, but an interesting read nonetheless. Silicon Valley’s Youth Problem
- About Agile as a buzzword and getting back to the core of the Agile manifesto, two related articles: Agile is dead (Long Live Agility) and Agile is Dead: The Angry Developer Version. I write something related to this a while ago.
I think that one of the most challenging things in my life as a developer is the Impostor Syndrome. Unless you’re stuck into a mediocre job, where everyone around you is pretty lame (and, believe me, if you’re in that situation, you want to get out as soon as possible), I think it is quite common to get that feeling of “wow, I don’t deserve to be here” feeling from time to time.
I am pretty terrible at myself, and I suspect I am not the only one. If I achieve something, that great feeling of “Oh, yeah!” will wear out after a few hours or days. I still remember sometimes failures I did at High School and feel bad about them. Yep, it sucks.
I have also perceived that it’s more dependent on yourself and team dynamics, that really on how smart people surrounding you is. Currently, I am in an astonishing place to work, where there are plenty of super amazing people. Surely I get impressed with great stuff often. But in previous jobs I had, where people were way less awesome but there were less communication, I felt it even worse.
Probably because we are painfully aware of all our limitations, the times we procrastinate, our failures, our own struggles with stuff that’s hard. But we perceive others more as their successes, their external results and their progress. One of the most common advice when performing live is to learn to “keep going” after a mistake, because it’s more important to continue that to allow that mistake to make you lose focus. With lack of positive reinforcement and seeing how valued is your work, it is very difficult to see your achievements and see yourself as a valuable member of a team.
I am more and more convinced that a great team and a great atmosphere are two of the most important things at job (if not THE most important), as well as in life. After all, we want to be reasonably happy while we’re working. Heck, we deserve to be happy at work.
That’s why I consider that giving good feedback to your co-workers is absolutely capital. Of course, when deserved. Of course, honest. It has to come from the heart. But I’m pretty sure that most of developers out there are way more eager to say and mean it “this is crap” than “this is fantastic“. And it shouldn’t be.
One of your most important duties as a developer is to show appreciation to your fellow co-workers so they know they’re great (and you know they are)
- Good tech lead, bad tech lead.
- Can we please please stop telling people that coding is easy?
- Confessions of an Intermediate Programmer. The perception and psychology of competence.
- The Science of Making your Story Memorable Some interesting advice about presentations. The presentation itself used as example is interesting as well.
- Thirty percent feedback to iterate faster.
- The classic “your problem with Vim is that you don’t grok vi” response in Stack Overflow.
- A very nice list of Python articles. Best Python 2013
- Companies and startups are different. Not only in size, but qualitatively. An startup is based on the search for a business model, while a company is based on the execution of a business model.
- A typewriter to print water paints. Amazing.
- How much is time wrong around the world, actually meaning how places in the world are synchronised to “12 AM when sun is higher”.
- A reflection about how Internet is so full of strong emotions and is so judgmental.
- When It’s your job to give bad news, because we don’t live in an ideal world.
- Writing is hard.
- This is a wonderful comment (in Hacker News)
- A great initiative to clean up Vim code. Neovim. It includes a fundraiser to help in the initial phase.