Learning Programming Languages Faster

I have known many people that are experts in linguistics that get dumbfounded by programming. Apon first consideration this makes no sense – until you come to the conclusion that its not the language that they’re having trouble with. In reality its the programming that they’re having trouble with and the language is just heavily associated with the act of programming itself. When you look at most people, when they try to learn programming, its all about memorization. They try to memorize the dos and don’ts, the key words, common syntaxes etc. The problem is, during all of this memorization, they forget to learn to program.

I was watching a college lecture that had been put on the internet that was focused on learning your first programming language. The professor appeared to be great, he taught the students how to create variables, about logical statements, functions, mathematical operators and the like, and then came their first problem: “Okay, so how would you tell if a number is even or odd?”. The class went silent as nobody had an answer to this simple problem. The professor then proceeded to explain that by dividing a number by two, if there is a remainder, it is an odd number. The reason they didn’t know how to solve this problem wasn’t because they didn’t know how to memorize a language – that’s simple – the reason why they didn’t know how to solve this problem is because they didn’t know how to program.

As I have stated previously, programming isn’t the simple act of typing. It is engineering. It is problem solving in a way that is (or better put, appears) abstract. When talking to new programmers, they often times make an emphasis on how many languages the learn. “I know 3 languages”, or “I know 11 languages”, they’re missing the point clearly. It’s not the learning languages that is important, its the learning how to program. Its learning how to problem solve. When you watch a new programmer learn to program, they’ll think in terms of “What feature would I use to solve this problem”, if you watch someone who is more experienced they tend to think in terms of “How would I solve this problem” and then “How would I implement that in this language” or “What tool will I use to implement my solution?”.

So, how can you learn programming/programming languages faster? Separate your learning into two categories, programming, and programming language. One thing you’ll notice about programming language books, is they all teach essentially the same thing. “This is how you use arrays. This is what arrays are.” or “These are the basic operators. Here is how you use them”. Once you’ve learned that, you don’t need to learn it again. Once you understand a programming methodology/ideology, you just have to learn syntaxes and key words.

You don’t even have to memorize key words/syntax, you just have to use the language, and stumble through your nonlogical errors until you can use the language comfortably.

One thing to be weary of is learning to program and then only advancing your skill in programming languages. Often times programmers will go on with a basic understanding, solving problems such as “How do you tell if a number is even or odd” with clumsy solutions such as (x % 2). They don’t even bother to learn enough about computers/software to come to the conclusion that (most) computers are digital machines, all you have to do is check the first bit to see if it is one or zero to figure out if its an even or odd number (x & 1).

My point in all of this is, as programmers we constantly have to learn new languages, and this task shouldn’t be a challenge to us. We should not program worse in a new language. Instead we should have a firm understanding of the concepts behind computers, behind programming, behind engineering, and we should be able to transfer these concepts with little effort. The secret to becoming a better programmer isn’t in learning the most languages, its learning to program the best.


About mdmstudios

I'm a programmer writing an Operating System
This entry was posted in Programming. Bookmark the permalink.

69 Responses to Learning Programming Languages Faster

  1. paradigm says:

    So you’re saying that programmers need to learn mathematics [specifically, abstract algebra]?

  2. david karapetyan says:

    You fail. Different languages will make certain concepts easier or harder to express so when someone tells you they know X languages and you only know Y languages and X > Y then chances are the guy that knows X languages knows abstractions that you are probably not familiar with. Metaprogramming and Ruby is the one that comes to mind first but the same can be said low level bit twiddling and C. So the distinctions you are making are not as sharp and people often learn actual programming why they are learning a programming language.

    • mdmstudios says:

      Having learnt 50 so languages or so, and programming with systems-level/low-level/graphical/server-programmers, I have found this to not be true after someone has learned more than 7 languages or so, presuming said person knows their ideologies and methodologies.

      Programming principles are what is important, the tools used to implement these principles are important, however, less so. They won’t make you a better programmer, at most they will speed up your programming, or make things a bit easier on you.

      Of course you are correct that some tools are better than others for different jobs, hence “What tool will I use to implement my solution?”.

      • andrew says:

        Any recommendations on good books about programming for beginners? I have read plenty of books on programming languages, but not too many on how to think like a programmer.

        Thanks for the article BTW!


      • mdmstudios says:

        I recall Stephen Kochan doing a pretty good job in his book Programming In C, however, for any first programming book to be successful, you have to try to make your own simple programs with what you know, and you need to do that constantly.

      • david karapetyan says:

        Ha, 50 languages, yet you are still raging about people new to programming who are unable to express even/odd parity. This post is completely useless. You are not addressing experienced programmers because they already know this and you are not addressing newcomers because because they haven’t done enough finger exercises to not worry about syntactical issues. Basically you are telling people “Look at how enlightened I am. I’ve discovered there is a difference between syntax and semantics”. You’re just another internet asshole who “knows” how to program.

      • James says:

        I think I agree with you, as long as the 7 aren’t just variants of Algol.

        I think the usual recommendations I see run along the lines of some version of assembly, C, one of the lisp dialects, something that’s purely functional, prolog, XML (and all the associated tools), the web development trio, a scripting language, and either Java, C#, or VB.net (in whatever order the student deems fit).

        OK, so that’s 9 or 11, depending on how you count “the web development trio.”

        Programmers who don’t diversify like that are just learning variations on the same language over and over. They never realize that there are other ways to think about the bigger-picture problems.

    • mdmstudios says:

      I’m sorry you feel that way. I assure you I didn’t write this over rage, I was just categorizing my thoughts, and saw no reason not to post them.

  3. That’s why I like learning new languages. I already know how to program. I just got to figure out some of the syntax and I am off to the races.

    • James says:

      For me, learning a new programming language is about learning a new way to think.

      Programming in, say, Haskell, is a *very* different experience than programming in C, which is also very different than programming in javascript (even though those two look similar).

      If you aren’t taking the time to learn the concepts behind the language, and *why* it is the way it is, then you’re probably missing out.

      Syntax is the easy part.

  4. karim says:

    most devs do copy paste work with the code when it comes to developing an application, there must be really few of them who work passionately on the CODE to really understand what is going on with the internal workings of the compiler or hardware for that matter.

    • mdmstudios says:

      I agree. I must admit I find the amount of developers that don’t know what they’re doing or just don’t care quite depressing.

      • Myles says:

        I must say that you two are not working at the right place if that’s the quality of software developer you’re encountering. I work with a group of 40 developers that are ALL passionate about their code. Mind you there are plenty of new people that aren’t as experienced, but they’re just as passionate about learning how to get that experience. There’s meager selection in the workforce compared to the demand, once there is any kind of economic downturn in the IT world (we kinda missed this last one) that kind of fluff will be trimmed away.

        Remember, the best programmers are 10 times more productive than the worst as paraphrased from the Mythical Man Month.

      • Doug Hill says:

        Take lots of pictures of your group and cherish your time with them. These will be the “good old days” someday. May you always be so fortunate.

  5. Chris says:

    “with clumsy solutions such as (x % 2)”…”all you have to do is check the first bit to see if it is one or zero to figure out if its an even or odd number (x & 1)”

    Not quite sure why you think x % 2 is “clunky” – I would bet the programmer who comes after you would have a better chance of understanding this as opposed to x & 1.

    • mdmstudios says:


      It is clumsy because it is inefficient, and arguably uglier/messier. Also if you are working with a group of experienced programmers, or may have a need to review op code/decompile, or write inline assembly, they will generally prefer that method. If I was working with a programmer that was unaccustomed to such code, I’d make a macro for it to make it easier for them to read.

      To each their own though.

      • Dave says:

        “The professor then proceeded to explain that by dividing a number by two, if there is a remainder, it is an odd number.”

        In other words, x % 2.

        Techniques such as “x & 1” in this case are simply alternative ways of accomplishing the same task. Programmers learn things like this with experience. We all start out writing code and our first priority is “Ok, how can I get this thing to compile without errors”. After doing that for a while it starts to change to “Ok how can I accomplish the same thing but more efficiently”. Thus “x % 2” changes to “x & 1”.

      • James says:

        I always start out coding for readability, then optimize when/as needed.

        I blame Michael Abrash. (Well, and all the inconsiderate jerks whose code I’ve been forced to maintain over the years).

      • Mad Bollie says:

        Yeah and x&1 suddenly won’t work if the way a number is stored changes.

        Really, in over 20 years experience as a developer I’ve never ever had to worry about the efficiency of (x % 2). Citing performance is a well worn excuse for writing obscure and difficult code.

        Ever wondered by software is so expensive and difficult to get right? It starts with the difference between (x % 2) and (x & 1).

        But it gets worse … your remedy for the situation is to further obscure with a macro, probably tucked into a header file somewhere, that a developer will have to go looking for. You could have just recommended a comment, for a piece of code that is unlikely to crop up that often.

        I agree with your original article that learning a language doesn’t really teach you how to be a programmer. But equally, there is a big difference between knowing how to program and being a professional developer.

    • harold says:

      Well no offense, but if a programmer doesn’t understand (x & 1) then that demonstrates a clear lack of understanding how a computer actually works. Such a person may write fine programs full of lovely design patterns, but he will never write be any good at optimizing for speed – which may not matter in most in many business apps, but they had better not try to get into gamedev.

      • Chris says:

        The processing speed between the remainder method and the bitwise operation is so minuscule if the operation is going to happen once in a while (as would be the case normally when you want to know if a number is even or odd).
        I know both ways, but the way that came to mind first was the x % 2 way. It works fine. If we need to optimize for some reason this area of code, then we can later. Any programmer worth his/her salt will solve the problem first than optimizer later.

      • harold says:

        Actually, the difference is HUGE, assuming no compiler optimization (but any reasonable compiler will optimize x%2).
        But that’s not the point. The point is, if a programmer sees x & 1 and then doesn’t have any clue what’s going on, he is a noob.
        Also, this may just be me, but x&1 is an extremely clear and simple operation – even conceptually – while taking a remainder is hard to reason about.

      • harold says:

        Also, binary numbers are certainly NOT just an implementation detail. There is no other realistic way of storing numbers. Other ways have been tried and invariably failed. But that doesn’t even matter – programming languages (even C) specify that their int type be binary or at least behave as such – so x&1 will ALWAYS work.

  6. Got says:

    I actually find it fascinatingly true what you are saying in this article. Programming and programming language are interrelated, but distinctly different. However, proficiency in a programming language enables the engineer to ‘know how to think’ in whatever language they choose to program in.

  7. David says:

    This distinction between language-learning and problem-solving is one of the reasons that I always end up going back to Prolog. The declarative semantics forces you to concentrate on the problem at hand. In order to accomplish anything you have to be able to specify the truth conditions that would constitute a solution to the problem at hand. That’s also what makes it so damn difficult, as well.

    I actively work in C++, Python, Ruby and JavaScript/HTML/CSS. I always end up going back to Prolog when I need to sharpen my problem-solving skills.

  8. Simone says:

    I totally agree with you, and i’ve learned this on my own skin.
    I like programming games. And after trying many many lenguages i have learend that the concept it’s almost always the same. Of course, in c you will have to work harder, and java will make your life easier. But the problem you will facing in a game, developing the same game, will be the same.

    Also i’ve found that math is really really important for any programmer.
    What you said about the mind of a non experienced developer can also seen in this example:

    New game developers usually ask for some collision library or function, experienced developers know that basic collision can be made with math that is teached in EVERY school.

  9. Pingback: Top Posts — WordPress.com

  10. Privat Bruger says:

    Obviously, a programmer should also known not to use a grey(ish) font on a dark background. Why should a blog entry be hard to read?

    • Myles says:

      Go back and read this at 1 in the morning the morning and contrast it to all the black text on white background. I think this color scheme is perfect. You might be able to blame your LCD for the poor contrast. Color profiles can make a huge difference.

  11. patata says:

    I think this situation is very similar when you learn a natural language: you learn words, you learn grammar … BUT the most important point is you must learn how to write, how to express yourself to properly communicate your thoughts

    Just right now, I’m attending a Java course. The teacher insists about libraries, syntax … but I think he’s missing the most important point: how to take advantage of Java to solve programming problems. IMHO, I should insists on something like code katas: a way to solve short problems and learn programming skills

    By the way, sorry for my English 🙂

  12. sam dolin says:


    if i follow this learning instructions for all languages. i would write in language x like i’ve learned already in language y. so why should we learn new languages? 😉

  13. Rafael says:

    I agree with the author. Who cares how many languages a person knows ? It all becomes machine language anyway. One important principle is: “Technique before tools” What really matters is knowing how a computer works, and what can be done with it. The rest is natural.

    • James says:

      The tools shape the technique.

      You [should] use a totally different technique when you’re using a paintbrush than when you’re using a hammer.

      Of course, if the only tools you have available are just different sized hammers, and you’ve never even heard of a paintbrush…

      (Not accusing you of this. But it applies to a lot of programmers I know).

    • Peter says:

      With the right tools you can do anything; Sometimes this means having enough ingenuity to know when you must invent and create a new tool. You may be able to get away with using an existing tool that is rudimentary for the job, but you will probably end up with bloodied knuckles and an end product that is so stripped that no one else will ever be able to fix or modify it again. When creating we should be willing to put in the extra effort to think through how our work will affect future generations of programmers. Is your work worth preserving and restoring or is it in need of bulldozing so someone else can start fresh?

  14. chuckh says:

    Thank you very much for this post! I like to think of myself as an experienced developer, but I got caught by the (x % 2) solution. As soon as you mentioned the (x & 1) solution, I immediately knew that that was the better solution and kicked myself for not thinking of it.

    We’re never “too” experienced to benefit from the experience of others. Thank you for sharing yours!

    • credzba says:

      Actually “if (x%2)” and “if (x&1)” produce identical code on most modern compilers.

      I used to work for IBM operating system, and one of the compiler developers came down to talk to us about how to optimize code so that the compiler could do a better job. It was over 20 years ago, but I clearly remember the advice.

      “Just write the code in the most logical and clear fashion you can. We write the optimizer for the 90% use case, so the more complicated you write the code, just to optimize it, the more difficult time the compiler has producing optimized code.”

      I have watched, and looked at generated code MANY times, and her words have always been true. There are times when compiler developers make mistakes, but those mistakes are better fixed in the optimizer than in your individual piece of code.

      • CurtainDog says:

        I’m really glad someone made this point.

        It’s the natural progression of the programmer – learn to trust the language, then learn to trust the tools.

  15. stevev says:

    The article is correct about the relationship of languages and programming skills.
    The most difficult thing to learn about a language is when NOT to use it.

  16. credzba says:

    I read the post, and the comments.
    In general, I think you are correct, and in fact many people before you have said the algorithm is more important than the implementation. I think that’s what your saying.

    I have seen people who program with the debugger, by that I mean they don’t read the code, understand the logic, then decide whats wrong with the logic. Instead they step through the program with the debugger, see what variable is not set properly, then write code to correct that specific variable.

    The end result works, but it rapidly becomes an unmaintainable mess.

    How does this tie back to your post? Well the developer who uses the debugger to solve the problem is of the category that learned the language, but not the logic.

    As for the person who said, oh then they should learn math logic, I disagree. Math is in itself just another language. It presents a way to represent problems and their solutions. Learning logic can be done in any language, including but not limited to mathematics.

    I can not tell you the best way to learn logic. When I teach my children, I tell them about the hardware and how it works. I then have them tell me how they would solve a problem in their native language (english). Only after we have the algorithm decided do we convert it into their target language (for their latest course).

    I think the ideas presented here are right, but they could perhaps be presented more clearly. There will also be the debugger programmers that don’t think… er I mean don’t think logic is required. They will learn the syntax of a language and think they are programmers, in fact they are coders, not programmers, but that distinction and classification was lost long ago.

  17. Steven says:

    I honestly think there are many very valid points here. Being at the beginning of my carrer as a programmer I think what I have found to be the most helpful way of advancing my ability is to see how many different ways I can accomplish a given task, look at the pros and cons and try to create something of my own. While I agree that the actual language itself is not the difficult part, I do not think that the most effecient way is always the best. Some of the best engineers in the world are the best because they can approach things a different way then what is the “standard” or “best practice”. I think the most important part of programming is getting to a point where you can look at a code block and grasp the concept of what the person was trying to do.

  18. Nouman says:

    The objectve here is to determine what is the most effective approach to become a good programmer. In my opinion, it kinda involves both, a solid knowledge of programming language, whats going on under the hood and specific know-how of the problem domain. You might be an expert in a specific domain and know very well how to solve a certain problem at hand but you won’t be able to tell that to a machine in a better way until or unless you are not a good speaker/coder of the language. We couldn’t have built computers any other way than the way we think, analyse and solve problems in our daily lives.

    So back to the question of how to approach learning to program? I would say you don’t have to be concious about the difference between the two (you won’t be able to see the point so early anyway). It would come apparent to you as you progress. I am happy the way I have learnt programming, it was same as the author mentioned but anyone who has been programming for some time has eventually come to realise that at some point. There is no point in rushing it I don’t think it will make a difference.

    • James says:

      Actually, the way we build computers is pretty much completely arbitrary.


      Von Neumann got a bunch of different types of engineers together and they threw together a prototype, as fast as they could.

      Then he died of cancer before he could use it in demos to raise funding to build one that wasn’t a complete kludge.

      In a lot of ways, that kludge is what everyone’s still using.

      (Credit: http://steve-yegge.blogspot.com/2006/03/moores-law-is-crap.html)

  19. Thomas Michaud says:

    When I studied Computer Science back in college, they did cover programming languages. I believe it’s important to know the history and types of programming languages: imperative, declarative and functional.

    But the key of the course was the computer theory classes. At the heart of these classes is the study of algorithms and the problem sets these algorithms can solve.

    You can learn to program without these knowledge … but you risk wasting your time and career trying to solve an NP problem.

  20. Doug Hill says:

    I’ve earned my living as a programmer for 35 years. When I hear some someone say they know so many languages, it does not in itself impress me. I start to think they know what they’re talking about when they say, “I prefer this language for quickly scripting a conversion between data formats, this language for a web app that will be maintained by inexperienced programmers, this language for large data-driven designs with many programmers, this language for parallel processing on GPUs, this language for highly user-interactive programs reliant on graphics processing. If I’m joining a large project using this language, here are the kinds of problems I’d look out for. These are the conditions that would suggest tying together two modules in different languages rather than rewriting one. This is the subset of this language I recommend given the time the team has to gel before we have to produce results.”

    This is very much in line with what you were saying — the goal is to get work done. The features of a language make sense in relation to the problem at hand, the other tools available, the knowledge of the programmers, and the history and future of the project. And, truth be told, on your own career needs.

    Programmers who have had sufficiently challenging problems to work on (given their level of development) are better oriented to learning what they need from a new language, and seeing where it could fit within their bag of tools. For example, given that I am proficient in Perl, and the people I work with can read it, what is the marginal benefit — to me, for the kinds of tasks I’m likely to face — in learning Ruby?

    An additional consideration that you may face if you stay active in programming for many years is that your knowledge of a language you have not used much lately may fall into the muddle of all the languages you have used in the past, and you will forget which details of syntax go with which language. Forgetting is a part of the life cycle of your knowledge of a language! This is where it is helpful to be building up an appreciation of the different qualities and utility of various languages, so you can still make a good choice of what language to dive back into. The details can be remedied by Google, that blessing to the aging programmer.

  21. Excellent point. Two observations:

    1. Not all languages are suited to the same representations. The language you use does affect the solution you choose. But I agree with you that first you should solve the conceptual problem, then see what tools are provided by your language to implement that solution. If you’re really lucky, you get to choose what language to use based on the implementation power that it provides.

    2. (x & 1) may not always be an option. Numbers may not be represented as binary integers, or the language may not have bitwise operators. As one of the other responders noted, (x % 2) is the conceptual solution, and (x & 1) is an optimization of it based on implementation details.

    • James says:

      But then, what do you do when you aren’t sure what conceptual problem you’re trying to solve?

      Exploratory programming can a very rewarding process. Even in business, when you have a project with very vague and malleable requirements.

      • I agree that exploratory programming is a great learning experience.

        In business, I do a lot of research programming, but that’s a bit of a different beast. I’ve always had at least some general requirement that needed to be filled, and the research was only about how best to fill it.

  22. rt says:

    Great article, I got a nice job as a localization engineer because of my linguistics experience. But the C/C++ environment was/is a struggle because I continuously approach the code as if trying to understand individual foreign words in a book, rather than trying to understand what they all mean when put together in sentences and paragraphs.
    Only now after a couple of years am I really getting that in order to understand what code is doing, you have to understand the meaning of it, as well as the language it is written in.

  23. Joe says:

    Hey, some of the points raised here are very much valid. But I believe you will all agree with me if I say we were limited by the technology of our time. For e.g. when I started programming we didnt have the support of the internet for discussion or sharing the best practices but now we do.
    I learnt programming the hard way and I go with a general assumption that if there is a problem then there is a solution. But if the solution is too complex or hard to implement then its no solution at all. Programmers need to identify the language that would help them to arrive at the optimal solutions to their requirements.

  24. Pingback: Всем сотрудникам отдела! |

  25. Greg says:

    I agree completely with this article. Programming is not all about learning how to type in a new programming language. The whole concept of programming is all about problem solving. How do you decompose a real world problem into a series of steps that can be simulated in a computer.
    This brings us to the concept of algorithms. Algorithms are basically a logical listing of steps that can be followed to solve a particular problem. An algorithm can be expressed in different forms, as natural languages, pseudocodes, flowcharts or programming language.
    The most important part of programming is being able to represent a complex problem as an algorithm.
    Once we have an algorithmic breakdown of a problem in one form (flowchart), it is trivial to convert it to another form (code) and vice versa.
    To learn how to progam better, you must completely understand mathematical logic. The concept of deductive reasoning and boolean logic forms the core of computer science and are critical knowledge a serious programmer should have otherwise the person is just a hobbyist.

    • Doug Hill says:

      I agree with you, and yet, as so often happens, your well expressed idea has brought to mind a partial counter example.

      I worked with a programmer who was weak on algorithms. She’d write an ugly piece of code over and over without thinking of how to encapsulate it. Yet she was a very valuable member of the team designing a web application. She would slog indefatigably at layout and user interface, chiseling away till it looked and felt right. She had no investment in the appearance of the code itself and never felt obliged to pause and tidy up as I would have done, so of course she had no nifty data structures or functions to subtly influence what she thought was a good user interface.

      When she was done, I’d go in and look for commonalities and produce structures that made the code easier to maintain and made it easy to reproduce her style throughout the application. Together we were much better than either would have been individually.

      I’m just saying that there is some internal tension between the qualities that overall are desirable in a programmer (encapsulation vs individual crafting or doing what the boss wants vs doing what you think he ought to want, for examples) and that sometimes it works better to have two unbalanced programmers working together than two balanced programmers. Luckily many of us are unbalanced. 🙂

      So deductive reasoning and boolean logic are critical knowledge for the serious programmer. But we don’t always have to be serious.

    • I agree. One thing to watch out for is a tendency to think only in terms of the languages you know. Thus, for example, a programmer might assume that a stepwise, imperative approach is the basis of any algorithm — when in fact it’s just a general limitation of many programming languages.

  26. I recall learning Ada in one day. The reason was because I wanted to get credit for a “data structures” class in uni, based on the fact that I took the class a few years prior at a different school. The instructor wouldn’t give me the credit because my class used Pascal, and her class uses Ada. Although she agreed that the concepts are the same, she was concerned that I wouldn’t be able to use Ada in future course work.

    I then did the unthinkable. I lied and said I know Ada, to which she responded and said, “Well, that’s good, then. Come by tomorrow, and I’ll give you a test on data structures, in Ada”. I smiled and thanked her.

    I now have less than 24 hours to learn a language. I used a trick I learned way back when, when compiling took so long, you had to write the code right the first time. So I came up with a pass criteria for myself: I will be able to write a small program in Ada, without using a compiler, all the way through, and not get a compiler error. If I get a compiler error, I have to erase the entire program, and type it in again, from memory. The program I came up with a very simple book manager, where you enter book titles and authors on the command line, and the program would give you the option to list the books entered, edit them and delete them. I used a linked list to store the books, and kept the list sorted (insertion sort).

    I probably wrote that code at least 50 times that night. It was such a pain when it’s all done, and I had a typo. DAMN, I have to rewrite it. Ctrl-A, Delete, and start over.

    But I have to say, once I was able to write the program all the way through without getting a single error, I felt pretty comfortable that I understood enough of Ada to go into a class that had that expectation. And that confidence helped me fill pass the test.

    The next time I learned a new programming language was C#, in 2000. I recall reading the spec on the language before the framework was released.. and I’m wondering, what is this “runtime” that they’re talking about.. Up to that point, Microsoft used the term “the runtime” to refer to their implementation of the JVM. But a few days later they released NGWS (Next Generation Windows Services), which got relabeled .NET.

  27. aod6060 says:

    Mhahahah good article man. It pretty much describes my mind set when I started programming. I was trying to memories everything but had a hard time trying to solve stuff. Until I tried a different language and found that most of them have similar concepts so instead of trying to memorise the all the syntax I just went in a try to figure out what similar concepts to use in language “A” and then use them in language “B”. And then try to solve a few simple problems that I did in “A” and re implemented them in language “B” to see if there are similar results. Then after that everything will fall into place. This is how I learn another in a short period of time when I need to.

    (x%2) == (x&1) interesting I didn’t know you could use logic operation like this to determine even or odd. The only logic operator I was using was the or “|” logic operator in c++ when I doing opengl programming. Its used to separate different buffer when cleaning it like so.
    I’ll have to look at them some more because this has been bugging me.

  28. Pingback: Chipping the web: March 5th -- Chip's Quips

  29. koolkabin says:

    that’s nice about programming and programming language.

    Out Sourcing Nepal

  30. I really like the concept of this blog… Thank you..!!

  31. Sbusiso says:

    PPl help me hre i want to learn Programming fast,i want 2 creat somethng using code mybe any software,Now on am doing A+

  32. Sbusiso says:

    OW I fogot swomthh hre,What’s the best or recommende btween Computer Science then I.T?

  33. ACSNOIR says:

    I am a new up coming programmer and I’ve been shy of programming for a very long time. before i even try to learn a programming language i tell myself that its too hard for me to learn. But i have now over come that foolish thought that as limited me for far too long. I now have the desire to learn and not stop learning. I want to be the best in all that i do and i am aiming to be the best. programming started out be very hard but now it is very fun and it feels great to be a programmer. All you need is the right attitude and the right reasons and you can do it.
    Let the programming begin!!!!!

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )


Connecting to %s