I'm a college student studying programming, and I feel like the whole picture isn't coming together. I just don't get it. I can write code and do all of my assignments just fine, but I feel like I'm missing something.
Anyways my question to experienced programmers. Did you feel like you were missing the big picture when you were a student? Or is it just me. And if so when did it come together?
Just keep doing and learning the basics, and it will all come together in a higher level of understanding at some point.
It is very easy when you are working on class assignments to have the feelings that you are dealing with. You wonder how in the world the stock problems you are working on actually relate to real programs that people use every day.
I would suggest that you think of some cool, basic application that you would be interested in using. It can be Mac, Windows, web-based, iPhone, etc; the important thing is that it is both real and interesting to you.
Then, start learning what you need to implement it. It is hard to write from scratch when you first start doing it, but you will learn a ton, and hopefully get a broader picture of what programming is about and how it can result in really cool projects.
I definitely had classes where I felt lost or like it wasn't coming together. Those were only a few classes though. Overall, I felt good about my choice and the big picture made sense.
It would be helpful to know how far along you are in your studies.
I felt that way when I started, but I was 6 years old at the time. It took 2-3 years for me to get a better handle on it (BASIC). But it still took several more years to get the handle on arrays, objects, etc...
Some people are natural at understanding programming, others have to work really hard at it.
In any event, here is my suggestion:
Don't worry about the "class" assignments -- do them as they come. Rather, create your own project that you will complete. When I was 9 years old, it was a paint program. When I was 13, it was a time tracking system. Etc...
By defining a problem to solve, it forces you to "get" the bigger picture. By the end of it (even if it is simple, but complete), you will no longer be "lost with Programming".
Then you can decide if you want to do it more, or find something else to do.
If you are able to complete your assignments, what are you missing. What big picture is there? You write code to complete tasks that the machines we have designed understand.
It is a completely man made science.
Am i missing what big picture you are talking about?
It takes a while to "get the big picture" when you first start programming.
I think the first time it started to come together for me was after the first time I went through an entire cycle of planning, design, implementation, and deployment of an application. When you're learning, you do lots of little exercises, which are not really all that useful in and of themselves. Until you complete a "real" project, it always feels like there's something missing.
I'd highly recommend joining an open source project. This will give you a much better feel for this, and has many other benefits, including helping build experience, learn a lot, and having some fun along the way.
I found that the real way for me to understand programming wasn't just to carry out university work when i attended, but to attempt to carry out real life practical applications that i made for myself.
As i was into web development i started creating various web applications to make various tasks easier for myself, people around me or employees. The more programs i created the more the whole picture clicked together due to the real practical example of doing it.
This helps you put all your knowledge, and gain more by researching and practising to fully piece it all together.
This worked for me :) hope it's helpful!
Working on an actual project will go a long way for you to see what software engineering is like if that is what you are missing. Programming is only one part of this. Working through a design, dealing with team members, deadlines, etc all present a different set of issues to work through. If you haven't done even a simulated "real" project as an exercise for class, try doing one yourself if you can get some interested classmates involved.
Although I don't know what you are studying I can understand because:
problem is
for an enquisitive mind, these always pose the question "What is happening underneath??"
My suggestion
Job done!
I've been writing code for almost 20 years and I feel like I'm missing something almost every day.
Software development is very abstract and often very much removed the the real world processes you might be modeling. Ie, if you were to organize a pile of book, you might not use a tree structure. If you were to organize a bunch of Book objects, a tree might be the simplest way to do it.
Not getting it is completely normal.
If you completely understand everything you are doing you are not likely to be learning anything.
Try to pick a simple pet project (the key here is simple) to solve a problem or remove an annoyance that you have. Learn as you go while coding your new project. If you give up, or don't gain enjoyment from the exercise, programming may not be an appropriate skillset for you to learn.
The more you learn, the more you'll realize how little you know.
For me the passion for coding has driven me to learn so much and take pleasure in so many small accomplishments that my own curiosity drives me to learn more than any "assignments". But it's also given me much humility to see how many nuances I missed when I first started, and to imagine how many more there may be.
Catch that spirit and you'll be a miles ahead.
Take pleasure in each small victory, and they'll mean more when they actually help you or those around you.
There were many times when I felt like I wasn't getting it or I wasn't ever going to be "professional grade". There are enough examples of stellar programmers around if you look hard enough that you will never quite feel like you measure up if that's the type of personality you have.
What finally did it for me was getting out into the real world and writing real code ... getting my hands dirty and having some true "ah-ha" moments where a couple lessons finally clicked for me. I still remember the feeling of utter clarity that came over me when I truly understood what polymorphism was useful for. I wish I could bottle that and hand it out to all the junior programmers I know.
So my advice is ... don't give up. If you love programming and it feels like it is something you want to do ... wait for it. Stick it out and you'll have your "ah-ha" moment too.
I don't know that there is a single "big picture" in programming. I think the important thing for you at this point is that you're understanding what you've learned so far and that you enjoy what you're doing. Enjoy it enough that you can work on something outside of class that people will actually use. Maybe an open source project or maybe a project of your own.
Your class assignments will help your programming ability to a degree, but class assignments are typically small in scope and useless in the real world. You need to make something that's real, long-lived, and big to really understand what programming's all about.
It's probably just Holden Caulfield syndrome, but it took me until the very last day of my degree before I grokked calculus, and that was just because I finally had a professor capable of an enlightening conversatiuon. I think it happens to everyone with something.
If the symptoms persist consider a career you don't feel lost in, because even if you can do it, why do something you aren't engaged by?
It's the application of your skills to a problem domain that will make it all "Click".
Until you solve a real-world problem and see people using your code in their everyday lives it's all abstract.
I started "programming" when I was 13 and so it was very much learning from looking at code making changes and then seeing what effect those changes had. When I went to University to study it was about learning how to structure things better and help me see the bigger picture. I guess you need to ask yourself what you feel is missing. I always got a kick out of writing some code then watching it run. If you don't enjoy the technical side of things then perhaps you might enjoy the high level design side more or the project management side of thing. I'd suggest you try and pin down what you feel is missing.
It all came together after my second C++ class when my teacher took the time to explain exactly what call by reference vs call by value meant, and how the stack and the heap are organized.
Other things like physical architecture classes, algorithm syntax parsing, and even networking helped build the big picture, but for me it was memory allocation and pointers.
By most accounts I'm pretty good at developing software and helping others develop software. But the whole idea of developing software didn't really start to click with me until my junior year when I took some classes hardware related classes. Did some assembly, wired up some microprocessors to peripherals and designed and fabricated a chip. Until then I was just doing assignments. After I learned what it actually meant when I was telling a processor to loop, jump, store memory, grab memory..., it finally started to click for me. But the real eureka moment was when I actually started "working". Solving real life technology problems is much different than what I was doing in school. I didn't have an assignment that said make this do this. I had to figure out what this was, and what it was supposed to do. Keep on it, school is teaching you skills to apply, life will give you stimulus to apply those skills. hope that helps.
I have a hard time "getting" something until I can use it to solve a problem that I actually have. For example, after reading up on generics in c#, I understood the "what" and "how", but not really the "why". It later hit me, as I was working on real code, that I could use generics to make my life easier. At that point, I "got" the big picture.
Do what I did: get a part-time job as a web-developer. You'll find out which language you like or program in, what the real world is doing when it comes to programming. It is so rewarding when a piece of code you wrote actually starts working and people think it's cool!
This is just college life, especially at large research universities and during the first two years. Professors are there primarily to do research and secondarily to teach. They generally are focussed on quantity of knowledge rather than quality. Hence, you tend to understand the material superficially and be able to do the assignments, but not feel like you really "get it". My advice would be to tough it out and try to find something that lets you do something more real world-oriented, either an internship, a research project, or more advanced, practical classes. Only then will any of it make sense.
You say that you are studying programming but don't indicate what kind of program you are in. Is it computer science, software engineering or another discipline like Computer Engineering?
I've found that this makes a huge difference as to how your teachers will approach the subject. I studied Computer Engineering myself starting off with electronics, discrete math and assembly language while simultaneously studying extremely basic 'Object Oriented Programming' techniques in Java it was really difficult to make sense of the OOP side of things.
It wasn't until my third year in a Software Engineering course where we were introduced to our first real OOP design patterns (Facade, Observer) and developed an entire project as a team using pair programming that things began to come together.
I would highly recommend reading through a book like Head First Design Patterns or the original 'Gang of Four' design patterns book or tackling something like 'Object Oriented Analysis and Design' to see how real applications come together as opposed to just programming some nonsensical Animal, Dog, Cat hierarchy stuff.
I found college programming courses to be so theoretical and low level to really inspire whatever interest I had in coding & computers. Deep down though, I have some deep and abiding appreciation of software/systems/logic that drew me back and to C++, C#, oop. That object oriented thing just appeals and I really enjoy the stuff they were trying to convey in school. Basically, when it comes down to it, do what makes you happy and evolve over time. They don't actually have a course for that, this is it.
Jake,
I can write code and do all of my assignments just fine, but I feel like I'm missing something
You are. There's a whole world of source control, APIs, design patterns, functional programming, bug tracking systems, configuration management, build scripts, and so on that they never teach in college. I was shocked the first time I encountered these things in the real world.
School will not prepare you to be a programmer out in the real world. Programming IS NOT about rote memorization of syntax, which seems to be what most CS courses have become nowadays. Programming is about problem solving, and unfortunately you can't teach people how to solve problems in a classroom. You only develop this skill by through practice, practice, practice.
When did it all come together?
For me, I was a programming hobbyist for a good 5 years before I started going to school. Afterward, I went to school to get my CS degree for two years, and finally I found a job as an entry-level developer. You'd think 5 years of programming + 2 years of school would mean something, but let me tell you: I sucked when I got that first job.
Sure, I did fine during the technical interview, but I simply sucked at writing code -- at the time I didn't even know the difference between a LEFT and an INNER join, and I had no idea how to write usable APIs in an OO way. I improved 1000x in the first 6 months on the job than I ever learned in all that time as a hobbyist or going to school.
The best way to get the "big picture" is to write a program for yourself. Pick something you would like to see a computer do, and write a program to make that happen. That way, you own the big picture, and it is there from the beginning. The "big picture" of a programming assignment is not a big picture at all - it is, or should be, to help you learn one or more specific programming techniques (or languages, or libraries, etc.) In any case, it didn't come from you or through you, so it's no surprise that you think you're missing it. Alan Kay said the best way to predict the future is to invent it; the best way to see the big picture is to paint it.
That's funny. I started out programming when I was in seventh grade, and always thought I knew what I was doing. Every year or two I'd learn something new, and realise I was completely full of it before when I thought that. But of course now I'd have full understanding. :-)
Perhaps your attitude is healthier? It's certianly more realistic.
I found college "classes" and "labs" were very "unreal" when it came to getting the big picture about how you will work in the real world with computers.
Probably the best class I ever had was a computer engineering class where we were given some programming tools and told to make a program that efficiently ran two electric trains around a complex series of crossing tracks, bridges etc.. The parameters for the assignment were that no train could ever stop, it had to remain moving and no collisions should happen.
Since there was only one real train workshop we all had to write in simulated environments and got very little time with the real trains. When preview time came the class got to watch as your program ran the trains through the circuit. The part NO ONE expected was when the instructor, after everyone had run and "passed" would randomly select one of you and bring you forward. He would then replace one train with a different one he had that was better lubricated or whatever. The results were rather spectacular as trains ended up all over the floor. It was very good lesson on thinking out of the box about what is the worst that could happen.
I found few classes gave me that experience but the real world work life did every day.
School assignments are just too leading. The problem is that schools teach you to write code, but not usually how to architect. The only way to learn how to architect is to build something from the ground up without someone telling you every step you need to do.
Think of something you'd like to build that is software. Figure out how to do it. Do it.
Once you've built something once, you will understand that you have to make the big picture yourself and then color it with code.
They don't really tell you this in school, they talk about all of the tools, but don't just say "build something using the tools".
What you learn in school are the basic building blocks. The real world is full of real problems. Bugs to fix that are causing real customer problems, doubled transactions, random crashes. Software to count real inventory, manage documents. School is abstract and dumbed down. Learning how to use a debugger, track bugs, deploy new versions is wholly different in the real world with real schedules, deadlines - you will engage with those tools and techniques because you need to get real things done. School assignments are mock situations, mock problems, minimized and sanitized so you can learn enough to learn how to do it 'out there'. I can think of no way to teach all this without taking many years trying to fix real world problems.
That feeling has followed me all the way through, the only thing that changes is your perspective. I had the same feeling when I was in school, and when I started my first job, I worked on 3 different softwares and wondered more about the requirements process. I started running my own projects, and then wondered more about architecture. I started building the architecture and wondered more about the project management process. I became part of the project team and then started to feel I was missing the perspective of the top-level execs. Then I found out most of these top level guys really are clueless about software. ;)
The world of software development is vast, and there are many paths to follow. It is good to have a plan, vital to have a focus, but equally you can follow where your curiosity leads. The only decent advice I can offer is to go where you feel you are learning something useful, and keep revising your 'plan' as new opportunities emerge.
This is all perfectly normal
What I have noticed in programming classes is that an assignment always makes sense to the instructor and to those that are experienced in programming, but almost never makes sense to the very persons it should be helping, the students. The students get lost on something that seems very obvious and illustrative to the instructor.
For example, a programming assignment showing the difference between value types and reference types. Makes complete sense if you already understand value types and reference types. But if you are the student, you are just doing what you are told to do. None of the code really makes sense, it isn't code you would every think to write on your own. So it feels unnatural, and feels like you are missing something, some bigger picture. The very thing that should help you understand the difference between value types and reference types is actually making you doubt you ever will.
My only advice...put in the time, code as much as possible, find simple tutorials, find harder tutorials, go to projectEuler.net and program every problem there that you can think of. Once you start looking at a problem and seeing code to solve it in your head, you will be "getting" it.
I would pick something you like, and then program it. This will go a long way to show you the big picture... perhaps using a mincrocontroller to alert your twitter when the temperature outside your room changes 5 degrees in an hour?
..A similar little project that caters to your interests will go a long way.
I'd say relax - you should panic only when you assume you know everything.
My best advice to you is to never stop learning. I've trained programmers right out of college in many of my various jobs and been a mentor to them. College will only teach you the basics of programming, but there is a whole world out there if you are willing to learn and find the right mentor. That may mean getting an entry level job and having the company that hires you train you or assign you a mentor.
If you cannot find a programming job try volunteering for an open source project and seek the advice of the other programmers and examine their code. Feel free to view the many web sites about the languages of your choice you want to program in, so that you can learn more. But beware any forum you get on could be hostile to newbies/noobs that is people just trying to learn more than the basics.
You might want to read whatever documentation or help files that come with your languages, and maybe buy a few books on them that cover more advanced topics that your college text covered. Most of the college texts teach the basics and how to write small programs, but corporations want large and complex programs and sometimes don't give you the option for analysis and design or even flowcharts and documentation, so beware. It can get stressful and dicey in those types of situations and you'll need the support of your team members and coworkers and management. If you cannot get support you will always have sites like this to ask questions on.
Sometimes development is learning from your mistakes. You code to the best of your ability and after you find a mistake you made, you change it and then learn from it. The best way to avoid mistakes is to adopt a naming convention and use variable names that make sense, for every object you open you close it off after it is no longer used and you manage your code so that it manages memory better, add in error checking check to see if the divisor is zero before doing a divide in your formula and check to see if the number is negative before taking a square root and check if a recordset item is null or empty before assigning it to a variable or database, you will learn more as you gain experience. Good luck!
Personally, I think that every student should start at the lowest level of programming: Assembly language. Not that every student should be an expert on Assembly, but that the first semester of programming should be about the basic concepts of Assembly: registers, pointers, binary arithmetic, etc (I can see no good reason to learn about more advanced stuff like CPU pipelines and caches, unless your work will be on the kernel driver side).
Then students should move on to C/C++, so they learn what objects are, and learn pointers vs. references, etc. Only then should they move on to high level compiled languages like C# or Java, or scripting languages like my favorite, Python.
I'm 39 now, but my first programming language was Assembly at age 12, and I took this path through my learning. As a result, I intrinsically and easily understand concepts like pointers vs. references, multi-threaded access to the same resource, linked lists, etc., which with young programmers seem to struggle.
A shortcoming of most classroom programming is that it mostly teaches writing code, which is important, but secondary to reading code. Obviously there are plenty of examples of illustrative code, demonstrating some point or other, but this seldom represents a meaningful learning experience.
I would venture that the big-picture you're missing is working on a big project. It can be hard to see how the classroom assignments and even projects scale to a full size application.
I'm not suggesting you try to build a large application (though that would certainly be just fine), but what you really need is to work at the source level of such a thing. Many have suggested that you work on a larger task than a classroom assignment, and I think this is the way to go, but you need to work on something that in some way involves another large project at the source level.
A good way to do this is to take a framework and push it to its limits. Create an application built on top of the framework that goes beyond what the framework was really built for.
For example, You can use Django for a blogging engine and learn a good deal about web programming, the python language, and so-on. Doing so won't require you to ever actually look at the framework at the level of its source code.
On the other hand, using that same framework for building a simple, web-based massive online game goes well beyond what django can do completely on its own. You will touch almost every part of the framework's functionality. You will have to really understand what a major portion of the framework does and how it does it. You will have to improve the framework in some ways, so that it actually does what it already almost can, and you will at the same time, have to create whole, new modules for things that are simply beyond what the framework ever could do. You will have to use almost every possible technology for building dynamic web sites.
Another strategy for getting a better feel for the programming craft is to work in a team. A major benefit will be that the project evolves quickly enough to stay interesting, and even reach a level of maturity. Another key aspect is that you will spend a major part of your time reading code from your team-mates, rather than pounding away at new code on your own. This also makes it essential to use some of the tools used in the wild that are rarely taught in class: bug trackers, source control, unit testing and online debuggers.
I was lost in comp sci to the point where I dropped out...well, I wasn't lost as much as bored. I think the answer is to go -outside- of coursework, and figure out what your real interests are are play around with those.
For example, figure out some kind of software that would be really fun to work with / develop. Then, do you own study and go deep into it, download what you need to start coding, and work that way.
School is often -really- unrealistic, often out of date in many ways...you need to own the process, the learning process, development process, find your own way to learn and connect that to an area you have a passion about.
Hope that helps!
I have to say that I have talked to a lot of college students who feel the way you do. They practice all these algorithms like merge sort, dfs or things of that nature but they still don't feel that they can program. I think the truth is that they can't. Because the amount of times you will use that in the real world is pretty small (unless you are specializing in that area). Most of the time programming is about knowing the API and just hacking through difficult (and many times mundane issues). Most of it is not super complex stuff like graphing algos.
The best advice in my opinion is to start doing programming projects on your own. Start with something simple, something you could accomplish in just a few days. I feel fortunate that I got my start when I was 14 on my own not really knowing any better. I just wrote applications without thinking about it. I think college makes it more complicated than necessary. Just my opinion though.
I faced the same issue, I discovered that I was way more adept at system management than I ever was as a programmer.
Consider what career you want after school. If you don't 'get' programming now, or if it bums you out, then you need to think of alternative career paths before you get out of college.
This is such a good question because it is rare for someone to be able to step back and see themselves in that way.
You may very well be missing something - there is always something to miss! Gone are the days of the renaissance man who can wrap his (or her) brain around a complete subject. Everyone is a specialist to some degree - you may become a C# jock on .NET but your expertise will be focused on the domain of your employer. That's what makes learning and applying the new stuff - DDD, TDD, and all the other things folks have listed - to your environment so fun and challenging.
You'll be asking yourself, 'xyz is wicked cool! But I have a HUGE codebase and deadlines to meet - how can I apply it?'
You're in a wonderful time though - your projects are over at the end of each semester and you get to move on. Enjoy that!
With programming, there is such a big picture that very few people really get "the big picture." People who say they get the big picture are liars, they may get one of many big pictures in programming, but are naive to think they get the complete big picture.
Play with some pet projects. The best things you can do are to read as much code as possible and write as much code as possible. Eventually things will start to click.
As long as you remember that you will never know everything about programming and enjoy all the small victories you have along the way, you will continue to improve as a programmer.
This post might have been an emotional reaction to a low level of serotonin at the moment. Think about it. Highest-level judgments like this one are not pure logic, they are too prone to chemistry levels in your brain.
I'm about to graduate with a BS in CS, and I felt something similar to you when I started out. For me, what I needed was a broad but good understanding of the vertical slice of computing. When you first start out, it all can seem like magic. I had no intuition of how things were actually working under the hood, the low level of computing seemed very incomprehensible and far, far away from the Java programming I was doing. I really had NO idea how a complex video game worked from top to bottom, or how Windows was programmed, compiled, and executed (not that I now have a perfect understanding of either however). But once I took enough classes that helped me link all the layers together a little better, especially once I got familiar with C, it started to feel more tangible. It wasn't magic.
I'm sure most beginning programmers feel similar to you. And, in fact, a good portion of those who don't probably simply don't care as much about the big picture and thus don't have that sensation of not getting it.
If you really want to find out what your missing, you'll keep at it. After all, all those great progams and sites out there must have been written by someone else who got it, right?
If it doesn't bug you that much (pardon the pun) it won't matter too much that you never get it.
Fear not, march on as far as you feel like going.
It took me several years to just get a piece of the big picture. hahaha. There is no course for experience. Just keep at it.
To be successful in programming you need a Mental Model of the important things that are going on. Make a list of all of the major elements in the system/problem domain/program you are working on and see it you really understand each one, or is there one that is a big, cloudy, fuzzy mystery more than the others. If so, try to research that one until at least a high level picture of it is clear in your mind.
Nobody said it was easy! Good luck.
I started programming while at IBM. I took several self-teaching courses before I went to College.
In college I flunked Pascal once. Then I decided to learn by myself. So, I bought a book I understood just by browsing the pages, instead of the book I had to read for the Pascal class I had to take again (and, hopefully not flunk).
During summer break, everyday I went to the library and practice and learn all by myself.
When it was time to take that Pascal course again I aced it. And, best of all even the teacher asked me questions on how to do some programming stuff. So, all the students looked up to me instead of the teacher. So, programming became fun and challenging.
After that experience I knew I had to learn by myself and do things by myself.
I began creating solutions which I succesfully sold.
Everything began falling in place, I found my calling, I found the big picture inside of me.
I felt very confident with programming at college - I'd taught my self at home while at school in the 80's. But I still felt something was missing. I did all the hardware classes and missed the connection to software. I could see the registers and the maths in the CPU (just) but something was still missing. One day we did an experiment where we had to do microcoding to build machine code. Bang!!!! It made sense!
Nowadays I spend time trying to work out problems in designs and software complexity. still loads of missing things!!!!!
you will never get the big picture, of if you will, you will have to leave out the small details. Do you really think Bill Gates knows everything about the internal API of internet explorer?
Your life, being finite and single threaded, allows knowledge at a given level of resolution. You can either zoom in an area of the picture, or zoom out to see it complete, but missing the details. You cannot have the big picture and the details at maximum detail. That's why humanity discovered teamwork to be advantageous.
The important is always to stay curious. If you are curious, you know you don't know everything, and you also have a direction to expand, albeit just a little, the viewport of your "knowledge screen". That was for me since I was 6 years old. The difference is that with time I realized that I can have fun while increasing the viewport, and I give priority to this more than anything else.