Top products from r/learnprogramming

We found 1,262 product mentions on r/learnprogramming. We ranked the 1,804 resulting products by number of redditors who mentioned them. Here are the top 20.

Next page

Top comments that mention products on r/learnprogramming:

u/CSMastermind · 4 pointsr/learnprogramming

I've posted this before but I'll repost it here:

Now in terms of the question that you ask in the title - this is what I recommend:

Job Interview Prep

  1. Cracking the Coding Interview: 189 Programming Questions and Solutions
  2. Programming Interviews Exposed: Coding Your Way Through the Interview
  3. Introduction to Algorithms
  4. The Algorithm Design Manual
  5. Effective Java
  6. Concurrent Programming in Java™: Design Principles and Pattern
  7. Modern Operating Systems
  8. Programming Pearls
  9. Discrete Mathematics for Computer Scientists

    Junior Software Engineer Reading List

    Read This First

  10. Pragmatic Thinking and Learning: Refactor Your Wetware


  11. Code Complete: A Practical Handbook of Software Construction
  12. Software Estimation: Demystifying the Black Art
  13. Software Engineering: A Practitioner's Approach
  14. Refactoring: Improving the Design of Existing Code
  15. Coder to Developer: Tools and Strategies for Delivering Your Software
  16. Perfect Software: And Other Illusions about Testing
  17. Getting Real: The Smarter, Faster, Easier Way to Build a Successful Web Application

    Understanding Professional Software Environments

  18. Agile Software Development: The Cooperative Game
  19. Software Project Survival Guide
  20. The Best Software Writing I: Selected and Introduced by Joel Spolsky
  21. Debugging the Development Process: Practical Strategies for Staying Focused, Hitting Ship Dates, and Building Solid Teams
  22. Rapid Development: Taming Wild Software Schedules
  23. Peopleware: Productive Projects and Teams


  24. Slack: Getting Past Burnout, Busywork, and the Myth of Total Efficiency
  25. Against Method
  26. The Passionate Programmer: Creating a Remarkable Career in Software Development


  27. The Mythical Man-Month: Essays on Software Engineering
  28. Computing Calamities: Lessons Learned from Products, Projects, and Companies That Failed
  29. The Deadline: A Novel About Project Management

    Mid Level Software Engineer Reading List

    Read This First

  30. Personal Development for Smart People: The Conscious Pursuit of Personal Growth


  31. The Clean Coder: A Code of Conduct for Professional Programmers
  32. Clean Code: A Handbook of Agile Software Craftsmanship
  33. Solid Code
  34. Code Craft: The Practice of Writing Excellent Code
  35. Software Craftsmanship: The New Imperative
  36. Writing Solid Code

    Software Design

  37. Head First Design Patterns: A Brain-Friendly Guide
  38. Design Patterns: Elements of Reusable Object-Oriented Software
  39. Domain-Driven Design: Tackling Complexity in the Heart of Software
  40. Domain-Driven Design Distilled
  41. Design Patterns Explained: A New Perspective on Object-Oriented Design
  42. Design Patterns in C# - Even though this is specific to C# the pattern can be used in any OO language.
  43. Refactoring to Patterns

    Software Engineering Skill Sets

  44. Building Microservices: Designing Fine-Grained Systems
  45. Software Factories: Assembling Applications with Patterns, Models, Frameworks, and Tools
  46. NoEstimates: How To Measure Project Progress Without Estimating
  47. Object-Oriented Software Construction
  48. The Art of Software Testing
  49. Release It!: Design and Deploy Production-Ready Software
  50. Working Effectively with Legacy Code
  51. Test Driven Development: By Example


  52. Database System Concepts
  53. Database Management Systems
  54. Foundation for Object / Relational Databases: The Third Manifesto
  55. Refactoring Databases: Evolutionary Database Design
  56. Data Access Patterns: Database Interactions in Object-Oriented Applications

    User Experience

  57. Don't Make Me Think: A Common Sense Approach to Web Usability
  58. The Design of Everyday Things
  59. Programming Collective Intelligence: Building Smart Web 2.0 Applications
  60. User Interface Design for Programmers
  61. GUI Bloopers 2.0: Common User Interface Design Don'ts and Dos


  62. The Productive Programmer
  63. Extreme Programming Explained: Embrace Change
  64. Coders at Work: Reflections on the Craft of Programming
  65. Facts and Fallacies of Software Engineering


  66. Dreaming in Code: Two Dozen Programmers, Three Years, 4,732 Bugs, and One Quest for Transcendent Software
  67. New Turning Omnibus: 66 Excursions in Computer Science
  68. Hacker's Delight
  69. The Alchemist
  70. Masterminds of Programming: Conversations with the Creators of Major Programming Languages
  71. The Information: A History, A Theory, A Flood

    Specialist Skills

    In spite of the fact that many of these won't apply to your specific job I still recommend reading them for the insight, they'll give you into programming language and technology design.

  72. Peter Norton's Assembly Language Book for the IBM PC
  73. Expert C Programming: Deep C Secrets
  74. Enough Rope to Shoot Yourself in the Foot: Rules for C and C++ Programming
  75. The C++ Programming Language
  76. Effective C++: 55 Specific Ways to Improve Your Programs and Designs
  77. More Effective C++: 35 New Ways to Improve Your Programs and Designs
  78. More Effective C#: 50 Specific Ways to Improve Your C#
  79. CLR via C#
  80. Mr. Bunny's Big Cup o' Java
  81. Thinking in Java
  82. JUnit in Action
  83. Functional Programming in Scala
  84. The Art of Prolog: Advanced Programming Techniques
  85. The Craft of Prolog
  86. Programming Perl: Unmatched Power for Text Processing and Scripting
  87. Dive into Python 3
  88. why's (poignant) guide to Ruby
u/ReverseEngineered · 2 pointsr/learnprogramming

Programming is a tool. I suggest finding another interest that you can apply it to. Robots, graphics, music, animation, sports, economics -- the possibilities are endless. Pick your favorite area, look at what kind of problems there are in that area that people use programs to solve, figure out how those sorts of programs work, and try to solve some of those problems yourself.

A few interesting examples:

  • Project Euler has a set of challenges relating to both math and computer science that will stretch you to learn more about both.
  • Python Challenge is basically a series of puzzles that challenge you to do new and interesting things with Python. Granted, several of the puzzles are quite similar and some of the libraries they reference are deprecated, but it's a place to start for programming challenges.
  • Programming Computer Vision With Python talks all about using programs to do things like find objects in pictures and track them even at different sizes and angles. Lots of great examples.
  • Programming Collective Intelligence talks about putting together data from different sources (primarily websites) and finding patterns. It deals with many machine learning concepts in ways that are practical and interesting. Things like modelling and predicting, optimizing, clustering (finding similarities), searching and ranking, and pattern recognition.
  • Arduino Robotics describes many robots you can build with relatively common parts that can be programmed using the inexpensive, C-based Arduino microcontroller platform. I've made several of these myself.
  • Digital Signal Processing is all about writing software that takes advantage of advanced math to manipulate signals in many ways. It's invaluable for audio, but you see it used with graphics, digital communications, and many other areas.
  • There is a subset of sports fans that really enjoy statistics and software can be very valuable for them. Things like comparing players across eras, predicting future performance, and helping to find high-value players. The general field is called Sabremetrics. I looked deep into it in relation to major league baseball. Two books that I found valuable are The Book: Playing the Percentages in Baseball and Baseball Between the Numbers.
  • Programmable games are cool too. Things like CROBOTS, CoreWar, RoboWar, and Robot Game. It's just as fun building the simulation environment as it is building the bots that compete within them.
  • Pick up any book on algorithms. Learn to apply the basics like binary search, insertion sort, radix sort, memoization and linear programming, Dijkstra's algorithm, and Newton's method for root finding.
  • Grab another book on data structures. Make sure you understand the differences between arrays, linked lists, hash tables, and trees. Learn about unique and useful things like binary trees, radix trees, heaps, and queues.
  • Learn how to write better code. I recommend books like Code Complete and The Pragmatic Programmer.

    Whatever you do, as you clearly pointed out, you have to be interested in it or you'll grow bored and give up. Find something that is interesting to you and pursue it as wide and deep as you can.
u/shhh-quiet · 2 pointsr/learnprogramming

Your mileage with certifications may vary depending on your geographical area and type of IT work you want to get into. No idea about Phoenix specifically.

For programming work, generally certifications aren't looked at highly, and so you should think about how much actual programming you want to do vs. something else, before investing in training that employers may not give a shit about at all.

The more your goals align with programming, the more you'll want to acquire practical skills and be able to demonstrate them.

I'd suggest reading the FAQ first, and then doing some digging to figure out what's out there that interests you. Then, consider trying to get in touch with professionals in the specific domain you're interested in, and/or ask more specific questions on here or elsewhere that pertain to what you're interested in. Then figure out a plan of attack and get to it.

A lot of programming work boils down to:

  • Using appropriate data structures, and algorithms (often hidden behind standard libraries/frameworks as black boxes), that help you solve whatever problems you run into, or tasks you need to complete. Knowing when to use a Map vs. a List/Array, for example, is fundamental.
  • Integrating 3rd party APIs. (e.g. a company might Stripe APIs for abstracting away payment processing... or Salesforce for interacting with business CRM... countless 3rd party APIs out there).
  • Working with some development framework. (e.g. a web app might use React for an easier time producing rich HTML/JS-driven sites... or a cross-platform mobile app developer might use React-Native, or Xamarin to leverage C# skills, etc.).
  • Working with some sort of platform SDKs/APIs. (e.g. native iOS apps must use 1st party frameworks like UIKit, and Foundation, etc.)
  • Turning high-level descriptions of business goals ("requirements") into code. Basic logic, as well as systems design and OOD (and a sprinkle of FP for perspective on how to write code with reliable data flows and cohesion), is essential.
  • Testing and debugging. It's a good idea to write code with testing in mind, even if you don't go whole hog on something like TDD - the idea being that you want it to be easy to ask your code questions in a nimble, precise way. Professional devs often set up test suites that examine inputs and expected outputs for particular pieces of code. As you gain confidence learning a language, take a look at simple assertion statements, and eventually try dabbling with a tdd/bdd testing library (e.g. Jest for JS, or JUnit for Java, ...). With debugging, you want to know how to do it, but you also want to minimize having to do it whenever possible. As you get further into projects and get into situations where you have acquired "technical debt" and have had to sacrifice clarity and simplicity for complexity and possibly bugs, then debugging skills can be useful.

    As a basic primer, you might want to look at Code for a big picture view of what's going with computers.

    For basic logic skills, the first two chapters of How to Prove It are great. Being able to think about conditional expressions symbolically (and not get confused by your own code) is a useful skill. Sometimes business requirements change and require you to modify conditional statements. With an understanding of Boolean Algebra, you will make fewer mistakes and get past this common hurdle sooner. Lots of beginners struggle with logic early on while also learning a language, framework, and whatever else. Luckily, Boolean Algebra is a tiny topic. Those first two chapters pretty much cover the core concepts of logic that I saw over and over again in various courses in college (programming courses, algorithms, digital circuits, etc.)

    Once you figure out a domain/industry you're interested in, I highly recommend focusing on one general purpose programming language that is popular in that domain. Learn about data structures and learn how to use the language to solve problems using data structures. Try not to spread yourself too thin with learning languages. It's more important to focus on learning how to get the computer to do your bidding via one set of tools - later on, once you have that context, you can experiment with other things. It's not a bad idea to learn multiple languages, since in some cases they push drastically different philosophies and practices, but give it time and stay focused early on.

    As you gain confidence there, identify a simple project you can take on that uses that general purpose language, and perhaps a development framework that is popular in your target industry. Read up on best practices, and stick to a small set of features that helps you complete your mini project.

    When learning, try to avoid haplessly jumping from tutorial to tutorial if it means that it's an opportunity to better understand something you really should understand from the ground up. Don't try to understand everything under the sun from the ground up, but don't shy away from 1st party sources of information when you need them. E.g. for iOS development, Apple has a lot of development guides that aren't too terrible. Sometimes these guides will clue you into patterns, best practices, pitfalls.

    Imperfect solutions are fine while learning via small projects. Focus on completing tiny projects that are just barely outside your skill level. It can be hard to gauge this yourself, but if you ever went to college then you probably have an idea of what this means.

    The feedback cycle in software development is long, so you want to be unafraid to make mistakes, and prioritize finishing stuff so that you can reflect on what to improve.
u/TheAdventMaster · 3 pointsr/learnprogramming

Something like Code: The Hidden Language of Computer Hardware and Software may be up your alley.

So may be From NAND 2 Tetris, a course where you build a computer (hardware architecture, assembler, OS, C-like compiler, and programs to run on the OS / written in the compiler) starting with just NAND.

At the end of the day though, the way things work is like this: Protocols and specifications.

Everything follows the same published IPO (input, processing, output) standards. Stuff is connected to and registers expected values on expected peripherals. The CPU, motherboard, graphics card, wireless modem, etc. all connect in the right, mostly pre-ordained places on the hardware.

In this vein, there's firmware level APIs for then communicating with all of these at the BIOS level. Although as far as I'm aware, "actual" "BIOS" is no longer used. UEFI is instead:

This is what Firmware is / is built on-top of. Operating systems build on top of these. System calls. Operating systems communicate under the hood and expose some number of system calls that perform low-level actions like talking to devices to perform things like file access or network I/O. A lot of this stuff is asynchronous / non-blocking, so the OS or system will then have to respond to an interrupt or continuously check a registry or some other means of getting a response from the device to see if an operation completed and what its result was.

Loading the OS is one thing the BIOS is responsible for. This is through the bootstrapping process. The OSs are located at very specific locations on the partitions. In the past, the only command you had enough room for within BIOS / pre-operating system execution was to load your OS, and then the OS's startup scripts had to do everything else from there.

Once you have an operating system, you can ask the OS to make system calls and invoke low-level API requests to get information about your computer and computer system, such as the file system, networks, connected drives and partitions, etc. These calls are usually exposed via OS-specific APIs (think the win32 API) as well as through a command-line interface the OS provides.

New devices and I/O from/to those devices communicate through firmware, and interrupts, and low-level system calls that are able to communicate with these firmware APIs and respond to them.

Just about anything you can think of - graphics, audio, networking, file systems, other i/o - have published standards and specifications. Some are OS-specific (X windowing system for Linux, DirectX win32 API or GDI on Windows, Quartz on Mac, etc.). Others are vendor-specific but don't seem to be going anywhere (OpenGL, then nVidia vs AMD driver support which varies across operating systems, etc.).

The biggest hardware vendors and specification stakeholders will work with the biggest operating system vendors on their APIs and specifications. It's usually up to device manufacturers to provide OS-compatible drivers along with their devices.

Drivers are again just another specification. Linux has one driver specification. Windows has another. Drivers are a way that the OS allows devices and users to communicate, with the OS as a middle-manager of sorts. Drivers are also often proprietary, allowing device manufacturers to protect their intellectual property while providing free access to use their devices on the OS of your choice.

I'm not an expert in how it all works under the hood, but I found comfort in knowing it's all the same IPO and protocol specifications as the rest of computing. No real hidden surprises, although a lot of deep knowledge and learning sometimes required.

When we get to actually executing programs, the OS doesn't have too much to work with, just the hardware... So the responsibility of slicing up program execution into processes and threads is up to the OS. How that's done depends on the OS, but pretty much every OS supports the concept in some sense.

As far as how programs are multi-tasked, both operating systems and CPUs are pretty smart. Instructions get sent to the chips, batched and divided by them and the computational results placed into to registries and RAM. Again, something I'm not a huge expert in, and it honestly surprised me to find out that the OS is responsible for threading etc. I for some reason always thought this was at the chip level.

When you include libraries (especially system / OS / driver libraries) in your code, you're including copies of or references to OS native functions and definitions to help you reference these underlying OS or system calls to do all the cool things you want to do, like display graphics on the screen, or play audio. This is all possible because of the relationship between OS's and device manufacturers and the common standards between them, as well as the known and standard architectures of programs designed for OS's and programs themselves.

Inter-program compatibility is where many things start to become high level, such as serialization standards like JSON or XML, but not always. There are some low-level things to care about for some programs, such as big- vs little-endian. Or the structure of ASM-level function calls.

And then you have things like bitcode that programs like Java or JavaScript will compile to, which are a system-independent representation of code that most often uses a simple heap or stack to describe things that might instead be registry access or a low-level heap or stack if it had been written in ASM. Again, just more standards, and programs are written according to specifications and know how to interface with these.

The modularity of programming thanks to this IPO model and the fact that everything follows some standards / protocols was a real eye opener for me and made me feel like I understood a lot more about systems. What also helped was not only learning how to follow instructions when setting up things on my computer or in my programs, but learning how to verify that those instructions worked. This included a lot of 'ls' on the command-line and inspecting things in my debugger to ensure my program executed how I expected. These days, some might suggest instead using unit tests or integration tests to do the same.

u/Finbel · 29 pointsr/learnprogramming

If you're working on your math and might pursue a CS degree I'd recommend Cracking the Coding Interview. I actually haven't read it myself but it's a highly recommended book often mentioned on subreddits like /r/cscareerquestions

EDIT: Perhaps pair it up with books on algorithms and data structures so you get comfortable in working with, lists, arrays, trees, graphs etc :)

EDIT: (currently 0) Why would someone down vote this? I just don't understand why?

EDIT: Someone mentioned that it could perhaps be because I hadn't read it myself so I thought I'd add a heartfelt recommendation by /u/amputect that I just read in the authors AMA:

> Gayle, I don't have a question, but I wanted to say that your book helped me get two programming jobs. I used to push grocery carts in the arizona summer, now I work for Google. I also, like, went to college and learned and stuff, but your book was a huge help in prepping for interviews. Thanks to you, I felt more confident and more prepared, and I was able to interview with several major tech companies without fear vomiting a single time which for me was a pretty big deal.
Seriously, thank you, thank you, thank you. Your book is great, I recommend it to everyone. You are a fantastic writer and a brilliant human being. Thank you!

u/juggerthunk · 3 pointsr/learnprogramming

I got my start by taking AP CS in high school. However, I had already gone to college and that was a while ago, so I read some books on the commute to/from work.

Initially, I read Sams Teach Yourself PHP, Mysql and Apache all in one to learn PHP.

Immediately afterward, I read Murach's Java Se 6 and Beginning Java Objects to learn Java.

Most recently, I read a portion of C++ Primer Plus, but got very sick of it. I've read most of Accelerated C++

I have a few other books on C# to read when the time comes to actually write code.

By the time I had read all of the above, I felt pretty confident on how to structure a program, regardless of language. As such, I was able to pick up Python and JavaScript quite easily just by reading online documentation at and W3Schools. When I'm writing a web app, I'll rely pretty heavily on PHP's and MySQL's online documentation to help me with whatever syntax quibbles I may have.

I still want to read Game Coding Complete and I'll probably want to find a few resources on programming within XCode.

They all tend to follow the same programming paradigms, to be honest. Java did a good job in getting me into an OOP mindset and C/C++ did a good job at helping me think about how to program things without layer of abstraction. Once I learned these concepts, it was pretty easy to get started with a new language. Programming in PHP can be super sloppy, but taking what I learned from other languages, I'm usually able to write fairly clean code in PHP (especially when I learned how to use classes).

I wouldn't recommend all of the books above, to be honest. I didn't have much ability to do online training at the time and compiled lists of books weren't nearly as useful at the time, so I relied mostly on Amazon book reviews. I'm sure you can find a few choice books on each language you want to learn and go that way. If you were to read books, I think Accelerated C++ is a good book, but works best if you already have some experience programming. I remember like Beginning Java Objects more than Murach's, though both are great as references (which is why they're both still in my bookshelf). C++ Primer Plus spends too much time teaching C and not enough time teaching C++ (you spend pages upon pages learning about C-style strings, aka char arrays, rather than just using the String Class, but I digress).

Ultimately, I could read a bunch about a language, but I never truly learned the language until I started writing in it. I've written a handful of programs just as proofs of concepts and I recommend you do the same while learning any language.

u/fajitaman · 4 pointsr/learnprogramming

The usual advice is "get out and program!" and that works, but it can be very tricky coming up with something to write that's also satisfying. The idea is that you learn best by doing, and that many topics in programming can't really be learned without doing. All that stuff is true and I'm not denying that at all, but some of us need more. We need something juicier than spending hours configuring a UI for a project we couldn't care less about. It shouldn't be an exercise in masochism.

I guess what I'm saying is that there are a lot of ways to learn to write code and books are great if you can really sink your teeth into them (a lot of people can't). Code Complete is a great book on the practice of programming. You also say that you "get" OO pretty well, but it might open your eyes to read up on design patterns (e.g., Head First Design Patterns). You have a long way to go before you really get it

In addition to those, you could delve deeper into your languages of choice. There's no way around JavaScript if you're a web programmer, and a book like JavaScript: The Good Parts is pretty enlightening if you've got some experience in JavaScript already. It's a pretty interesting and unusual language.

But sometimes programming is about building gumption, so instead of just being practical, try to figure out what you like about computers and keep going deeper into it. If you have an interest in computer science and not in just building apps, then something like Structure and Interpretation of Computer Programs could instill in you an enthusiasm for computers that trickles down to everything else you do. If you're more interested in web design, there are probably similarly interesting books on artistic design principles.

I think what I'm ultimately saying is that you should find what you enjoy doing and just go deeper down the rabbit hole, getting your hands dirty when it's appropriate and interesting.

u/Medicalizawhat · 10 pointsr/learnprogramming

Well I left school in 10th grade, travelled around and worked odd jobs for most of my 20's until one day while working a particularly shitty job I realized if I didn't make a change soon I'd be doing jobs like that for the rest of my life! So I went to university and studied something unrelated for a few years. Somewhere along the line I clicked a link on Reddit that said "Try Ruby!" and it took me to a site kindof like Code Academy with a tutorial for Ruby. I tried it out, got instantly hooked and started spending all my free time programming!

Eventually it got to the point where programming all the time made me fail a few units so I dropped out of uni. I enrolled in a programming course but that didn't work out either, so I decided to take six months and just teach myself programming full time. It was a really awesome time, I'd wake up every morning and work on my projects, take online courses and read programming books all day!

Eventually I started running out of money. I didn't think I was good enough yet but the fact that I was rapidly becoming destitute gave me the kick I needed to start applying for jobs. I was incredibly lucky in the fact that I ended up getting hired at the first place I applied. Apparently they chose me over the other candidates because of my "life experience" and the projects on my Github, although the fact that I was willing to work for peanuts helped as well haha.

That was over six months ago and I'm still really enjoying it. If I were to offer some advice it would be to just stick with it. Even when you doubt that you are good enough, or smart enough, or that this whole learn programming idea might not work out at all and you'll never get a job - keep at it! If you enjoy programming and put the effort in then someone, somewhere will give you a chance, and all you need is one chance.

Also, make sure to take projects through to completion and post them on your Github. One simple, well written project is more valuable then 20 half finished ones. Code your projects knowing that your future employer will be reading it and deciding whether or not to hire you!

To that end, I'd highly recommend Clean Code. This book really helped me, but I'd recommend reading it after you've written a project of your own. Then, as you read through the book, go through and refactor your code.

Finally, when you're thinking of projects, don't worry about trying to create something amazing straight off the bat. Pick anything that interests you, maybe scratch an itch, or even re-implement something that already exists. At the end of the day the idea does't matter as much as the fact that you've spent the time and effort to build something. If you look at my projects, they're boring as anything! But they were good enough to get my foot in the door.

All the best!

u/baultista · 2 pointsr/learnprogramming

I've always felt like C is a good language for a programmer to think in. With that being said, I often recommend that a programmer who doesn't need to know C++ learn C if (s)he wants to learn something that will improve his/her skill across the board.

C will give you a good appreciation of what's going on behind the scenes in many of the languages you use. You'll get an appreciation for how passing by value and reference works in other languages thanks to pointers. You'll learn how your strings are actually managed in memory. You'll have a better understanding of how many of those built-in generics you may use (List<>, LinkedList<>, HashMap<>) actually work, because if you want to use them in C you'll have to implement them yourself or download a source file and read it to understand the author's implementation.

This knowledge will help you build more elegant solutions. You'll be less sloppy and gratuitous creating new strings anywhere and everywhere, and may even find yourself using references more often. Your code may or may not be cleaner, but you'll have an appreciation for how and why you should write code for runtime efficiency. You'll be more likely to use the right data structure for your task at hand.

The best part is that C has a great standard resource for learning the language. Pick up The C Programming Language Second Edition and read it cover to cover. By the time you're done you'll know everything you need to know about C, and will have a wonderful reference in the even that you need to use C later on.

If you want to improve your object-oriented programming skills, you don't need to learn a new language. It is best to learn OO independent of any language in order to gather a strong understanding of the underlying concepts and to be able to apply it to any language. Craig Larman's Applying UML and Patterns is the best book I've ever read on the subject.

u/YuleTideCamel · 162 pointsr/learnprogramming
  • Clean Code is a really good programming book. It's technical in that it gives you best practice, but you don't need a laptop or to code to follow along, you can just absorb the information and follow along with the simple samples (even if it's not your primary coding language).

  • The Clean Coder is a great book about how to build software professionally. It focuses on a lot of the softer skills a programmer needs.

  • Scrum: The Art of doing twice the work in half the time is a great introduction to scrum and why you want to use it. Agile (and scrum in particular) can have a major improvement on the productivity of development teams. I work for a large technology company and we've seen improvements in the range of 300% for some teams after adopting scrum. Now our entire company is scrumming.

  • Getting Things Done has personally helped me work more efficiently by sorting work efficiently. Having a system is key.

  • How to Win Friends and Influence People I often recommend devs on our team read this because it helps with interpersonal communication in the office.

  • Notes to a Software Tech Lead is a great book so you can understand what a good lead is like and hopefully one day move up in your career and become one.

u/bridgesro · 2 pointsr/learnprogramming

I'm still not an expert yet, so I can't promise that my recommendation is the best path. Looking back at where I struggled and what worked for me, I'd say the best order to learn programming from the beginning is:

  • Basic problem-solving
  • Basics of programming
  • Introduction to your chosen language
  • Software design and object-oriented programming

    If I was helping someone start in programming, I'd have them go through the first chapter of Think Like A Programmer for basic problem-solving techniques, then Optional Bits – which my friend wrote – for programming basics, then Codecademy to learn the syntax of the language they're interested in (Treehouse is a good alternative if Codecademy doesn't have the language you want or if you learn better from video lessons).

    Problem-solving is the best place to start because it's going to drive how you look at every program you write. Good problem-solving techniques also help build confidence, which is really important for a beginner – lack of confidence really held me back my first year of coding. I also found it easier to understand the different courses I took and books I read once I got a better grip on how to solve problems.

    After that, learning programming basics should always come before learning a specific language. It makes learning new languages easier and, combined with problem-solving, helps you to understand how to put together a program together. If you can do that, then it doesn't matter which language you pick; the syntax is just filling in the blanks.

    Learning a language at this point would just be figuring out what keywords the language uses – you won't have to learn both programming and language-specific syntax at the same time. A basic introduction like Codecademy is probably good enough for this step if you've filled in their blanks with the other steps first.

    Then software design will help you learn things like OOP, coupling and managing dependencies, single responsibility, etc.

    Again, I'm still in the early stages of programming myself, so I can't promise this is the best way to do it. In retrospect, I think that order would have worked a lot better for me when I first started. Hope it helps!
u/random012345 · 1 pointr/learnprogramming

Books on project management, software development lifecycle, history of computing/programming, and other books on management/theory. It's hard to read about actual programming if you can't practice it.

Some of my favorites:

  • Code: The Hidden Language of Computer Hardware and Software - GREAT choice I notice you already have listed. Possibly one of my favorite, and this should be on everyone's reading list who is involved in IT somehow. It basically how computers and programming evolved and gets you in a great way of thinking.

  • The Code Book: The Science of Secrecy from Ancient Egypt to Quantum Cryptography - Another great history book on code and how things came to be. It's more about crypto, but realistically computing's history is deeply rooted into security and crypto and ways to pass hidden messages.

  • Software Project Survival Guide - It's a project management book that specifically explains it in terms of software development.

  • The Art of Intrusion: The Real Stories Behind the Exploits of Hackers, Intruders and Deceivers - A fun collection of short hacking stories compiled and narrated by Kevin Mitnick, one of the most infamous hackers. Actually, any of Mitnick's books are great. Theres a story in there about a guy who was in jail and learned to hack while in there and get all kind of special privileges with his skills.

  • Beautiful Data: The Stories Behind Elegant Data Solutions - Most of the books in the "Beautiful" series are great and insightful. This is one of my more favorite ones.

  • A Guide to the Project Management Body of Knowledge: PMBOK(R) Guide - THE guide to project management from the group that certifies PMP... boring, dry, and great to help you get to sleep. But if you're committed enough, reading it inside and out can help you get a grasp or project management and potentially line you up to get certified (if you can get the sponsors and some experience to sit for the test). This is one of the only real certifications worth a damn, and it actually can be very valuable.

    You can't exactly learn to program without doing, but hopefully these books will give you good ideas on the theories and management to give you the best understanding when you get out. They should give you an approach many here don't have to realize that programming is just a tool to get to the end, and you can really know before you even touch any code how to best organize things.

    IF you have access to a computer and the internet, look into taking courses on Udacity, Coursera, and EDX. Don't go to or pay for any for-profit technical school no matter how enticing their marketing may tell you you'll be a CEO out of their program.
u/TehLittleOne · 9 pointsr/learnprogramming

My suggestion is always to start with Python. It's a very high level language and it's very easy to learn. In fact, Python recently became the most popular language to teach beginners. I know you wanted to learn Java, but there are several things about it that make it not so great for beginners, as well as several things about Python that make it good for beginners (ask why if you're interested, but it may be a bit technical). As a programmer, you will likely learn a dozen or more languages (I've learned over a dozen in school), so saving Java for a bit later isn't really an issue. You'll find in programming that a lot of the important things apply to most languages, so learning these allow you to apply them to new languages quite easily. My university now uses this book in the first year computer science courses.

Get yourself situated with a free GitHub account. GitHub is my favourite version control. If you have a student email you can get a free private repository (so others can't see your stuff). If you don't have a student email to use to get one, you can still make a free account, but it will be public. What that means is that anyone who navigates to your account can see all your code. Since you're just starting out, it shouldn't matter if people browse your code, there's not much to see since it's just you going through the basics. GitHub has a tutorial for new users and also has a user-friendly client that makes it all really simple. You can save the more complex stuff for later until you're comfortable.

Once you've gone through Python and learned a bit, it's time to get into some of the language-independent things. Introduction to Algorithms is an amazing textbook. The authors are some of the most well respected people in the field and I've used it in school in more than one course. You can go through this at any time. I recommend you programming some of the things (they provide some code as well), and perhaps trying this stuff in Java might be a good segway from Python to Java.

u/michael0x2a · 1 pointr/learnprogramming

That's sort of a tricky one, because there are two distinct aspects to learning JavaScript. The first aspect is figuring out how to solve problems using code, and the second aspect is understanding the nuances of JavaScript. (Ideally, the second phase should require much less time, but unfortunately, JavaScript is a bit of a quirky language so even developers who are experienced at solving problems in other languages might need some adjustment time to get used to the unexpected bits).

Regarding the first aspect, I'm unfortunately a little out-of-touch with the JavaScript ecosystem, and am not aware of too many resources that I think do a good job of teaching you how to problem-solve using JavaScript (which, I should emphasize, is different, and probably harder challenge then just teaching you JavaScript).

That said, freecodecamp seems like a potentially good one. If you care only about JavaScript, you're probably going to want to skim through the first bits on HTML and CSS, but the exercises and projects they provide seem pretty damn solid.

Eloquent JavaScript might also be a good one -- the only main problem is that I think it ramps up a little too quickly in places (in particular, the chapters about writing objects). This might be a good "second resource", after you complete a more basic tutorial and have one or two projects under your belt.

Beyond taking courses, the best thing you can do for yourself is just constant practice, whether it's by working on exercises or working on your own personal projects. The only way to get better at problem-solving is via constant practice.

Regarding the second aspect, here are some good resources that I think do a good job of teaching the nuances and tricky bits of JavaScript. I would consider these beginner-intermediate resources -- they might not be entirely appropriate for somebody completely new to programming, but certainly would be useful for somebody who's completed one or two projects and wants a deeper understanding of JavaScript, or for an experienced programmer who hasn't used JavaScript before and needs to ramp up quickly:

  • JavaScript: The Good Parts -- it's a pretty small book, and does a good job of giving a very concise and precise definition of what clean JavaScript code looks like.
  • MDN's JavaScript guide -- this is a no-nonsense set of guides to JavaScript, and has a variety of different tutorials targeted towards different audiences.
u/JBlitzen · 2 pointsr/learnprogramming

You're asking a very complex question that the best current minds in the fields of sociology, politics, psychology, technology, futurology, neuroscience, education, and many others, cannot answer.

We just don't know what it is that makes a good programmer different from a bad one. We all have theories and ideas and notes and observations and anecdotes, but compiling them together doesn't generate an actual understanding of the subject.

So I'm sorry but there's no real way for anyone to answer your question.

I would look for local resources to double check wtf you're doing.

Befriend a trusted professor and visit them during office hours, or a trusted student or advisor or professional or something. Explain your concern and ask them to walk you through how they approach problems. Not the solution; just watch how they approach the problem and pay very close attention to it.

That's quite invaluable.

For instance, take SQL. If I get really stuck on a SQL problem, I go back to my root approach to it, which is to ask this question: if I had several tables of data printed out on paper, what would I tell a monkey to do to collate them and generate the output I want? That's all that SQL usually does; it explains to the computer how to collate and present diverse data tables.

And that's easy to forget when you're trying to think about join syntax or something and you're grasping at straws and trying to construct a pattern in your mind and it keeps unraveling because you don't have a good sense at the root level of what it is that you're trying to do.

Better programmers aren't defined by what they know, they're defined by how they think.

And I sense your problem is that you're trying to apply knowledge not without understanding it, but without understanding how to understand it.

Watch this, I'm about to do a cool programmer mental trick of segueing to what seems like a completely unrelated subject, but I'm actually following a mental thread that connects the two.

When linguists try to decipher ancient languages, they sometimes run into an interesting kind of trouble. Take Linear A as an example. They have the symbols. They have a pretty good idea of what some of them mean. But they have no idea how they go together or what most of them mean, because they have no context for deciphering the thing. It's completely inaccessible. For all scientists can tell, Linear A might as well be encoded symbols of sound waves which can only be translated intelligibly when played aloud. If they converted a Linear A script to MP3, it might come out a perfect rendition of All Along The Watchtower.

The problem isn't that they haven't unlocked the words, the problem is that they haven't figured out how the writers thought. And without knowing that, the words are probably unknowable. They could throw some together that have likely translations, but what sounds like "there is the sun" might actually mean "my dog ate my banana".

So the key to unlocking the language isn't to stare at the language and to try to wrestle words into place.

Instead, it's to research the culture that used the language, to try to learn more about the culture and how it functioned. Did it have a seat of government? Was it patriarchal or matriarchal? Was it militant or trade oriented or hunter/gatherer or what?

By understanding how the people lived, you get a sense of how they thought. And by understanding how they thought, you can start to figure out how they communicated. And more than one language over time has been deciphered in that way.

Or how about this; you don't speak french, but encountering a french person on the street, you're able to use hand gestures to ask them directions to something, and they're able to respond intelligently using hand gestures. How'd that happen? Because you both thought the same way.

This psychological question consumes exobiologists, because they're tasked with figuring out how to communicate with aliens who, by definition, don't think like us.

So what do they do? They return to the basic roots. And the simplest roots they can find are the hydrogen atom and the set of prime numbers. And maybe pi. Things like that. And people hear "math is the universal language" and sneer dismissively because math is boring, but it's actually true.

So I'm curious whether you're fluent in the universal language of computers, or whether you just think you are because you practiced writing linked lists 37 times.

Charles Petzold wrote a great book called "Code: The Hidden Language of Computer Hardware and Software". It doesn't teach you how to program, but it teaches you WHY you have to program. And by understanding the WHY, you get great inroads to the HOW.

I'd recommend taking a look at that if you can find it. "". Notice that the second book in the "Customers Who Bought This Item Also Bought" section is titled "Think Like A Programmer". Code has better reviews so I'd start there.

But that might help.

I don't think you're stupid, I just think that you aren't thinking the right way about the problems.

Or maybe it's a problem solving thing altogether. How do you do with Sudoku or other games like that? Or chess puzzles?

I dunno. This is all food for thought, and maybe some of it will stick.

ETA: Damn I wrote a lot. I'll save it and blog it someday, maybe. Anyway, I did a search on "how programmers think" and came up with this interesting article: "". It's interesting not because I entirely agree with it, and I couldn't find the other two parts of it anyway, but at the bottom of the first section, in bold, the author says that the big problem with some programmers is that they've been taught the HOW but not the WHY. So here again is someone supporting my point. Tricks and habits and stuff will only take you so far; at some point you have to learn the WHY in a way that lets you apply it and start coming up with your own HOW's as the need arises.

u/DeliveryNinja · 2 pointsr/learnprogramming

Read these books to get to grips with the latest techniques and ways of working. As an employer I'd be extremely impressed if you'd read these books. They will give you a big head start when trying to move into the professional work environment. Most of them will apply to any programming language but they mainly use Java as the example language but it's very similar to C#. It's books like these that are the difference between a beginner and an expert, but don't forget when you start coding 9-5 with good developers you will very quickly pick things up. We were all in your position at one point, if you get these read it'll all be worth it in the end!


C# in depth - I've not read this one since I do Java but I've just had a quick glance. This should be pretty useful and it's a respected publisher. I think you should start with this one.

Clean Code - Great book which explains how to write clean concise code, this 1,000,000x. It doesn't matter what language you are using it should apply where ever you write code.

Cleaner Coder - Another Robert Martin book, this one is easy to read and quite short, it's all about conducting yourself in a professional manner when you are coding. Estimating time, working with co-workers, etc.. Another good read.

Growing Object-Oriented Software - This book is about writing code using test driven development. It explains the ideas and methodologies and then has a large example of a project that you build with TDD. I just read this recently and it is really good.

Head first design patterns - This book goes through essential design patterns when coding with an object orientated language. Another essential read. Very easy to read, lots of diagrams so no excuses to not read it!

Work Methodologys


Succeeding with Agile


Start building stuff, get an account on linked in and state the languages you are working with. This will help as well because having something to show an employer is priceless.

u/negative_epsilon · 1 pointr/learnprogramming

> Is this a good way to highlight the code I used to build on top of the scaffold?

I did see it originally, I wasn't entirely sure that's what it was though. As to if it's a good way? It's a two-edged sword. The good side is that I do get to see your code, the bad side, however, is that it's not really what a README is for. I guess it's just indicative of how Github's being used lately-- remember that Github is supposed to be a repository of git projects, not really a portfolio. The README is supposed to be "how can I use this", or "how can I contribute to this".

It might just be my own personal bias in that negative side. I do appreciate the code sample. Some more critique if you don't mind? Note, I'm a professional developer, about 15% of my time is spent on node.js so things I say might be nitpicky but knowing the idioms can really help when it comes to writing JS code in a team.

$ is a really big function. The work is also nested in a setTimeout as an anonymous function. In general, you should break functionality out into small, bite-size functions-- maybe no bigger than 5-10 lines. This allows for maintainability, too, because smaller functions can be unit tested whereas large functions, especially anonymous functions, cannot be.

There are magic numbers a lot of places. i; i < 4; i++, what is 4? It's the number of photos to show, right? Name that constant, so it's easy to read. Also, super small thing but the idiom is usually for (var i = 0; i < 4; i++) { .. }, seeing i being defined elsewhere led me to believe it wasn't zero or it was dynamic (but it wasn't).

In fact, variable naming is a big thing too.

if ( === 4) {
var k = 3;
} else {
var k =;

What is k? What are 3 and 4?

if (photoArray[0].url === instagramPhotoUrl || photoArray[1].url === instagramPhotoUrl || photoArray[2].url === instagramPhotoUrl || photoArray[3].url === instagramPhotoUrl)

This is a mess. First thing, you're only using the else block, so check out DeMorgan's Laws. Basically, !(a || b) === !a && !b. Secondly, you can write it better in a number of different ways, the easiest of which (and the way I'd probably write it) would be to create a separate function call that looped over your photoArray and returned true if instagramPhotoUrl did not exist in your [[array]].url. Once it returned true, you can set your tempObject, and then break. Note, you should use break instead of setting uui = 20 for readability.

Finally, $http.put('/api/v1/Pages/' + page._id, page).success(function(data) { });. If you don't need to do anything with the returned promise, you don't need the success function. Degenerate functions clutter up the code. The documentation for it is here:$http#put

I'm not trying to be a dick here, please don't think I am. I'm a regular here in /r/learnprogramming because I love helping people, and especially people who program in one of the top languages I know. You can ignore everything I said if you want, I'm only trying to help. Code readability is among the most important things you learn when you start developing on a team. In fact, I'd recommend this book: . It really opened my eyes when I read it, hope it can do the same for you.

> My main question is this: is the market for Javascript developers in SF similar to that in other cities and will I find similar levels of success?

SF has a huge boner for node.js, so the JS developer community there is huge. There are also a number of jobs, probably the most out of any city, for modern web frameworks (node and rails are gigantic).

u/DaBritishyankee · 3 pointsr/learnprogramming

>What did/do you find hard about learning programming? If you could be specific about things that frustrated you or roadblocks that got in your way, that would be helpful.

The hardest thing I've found about learning programming is knowing where to start. If you're trying to learn without a mentor its really hard to know what you need to learn and how. To someone inexperienced with the field, learning to program seems as simple as learning a language, but the difficult part is learning to apply that to different problems. Overall, the hardest thing to learn is something that you don't know exists. As for a specific subject, I remember finding recursion and Polymorphism hard to understand the first time I encountered them.

>Did you choose to go to an institute of higher learning for programming instead of using the free resources that are all over the net? If so, why?

I am an undergrad sophomore at Northeastern University, studying Computer Science. I chose to study computer science at university instead of using online resources, because I realized that there was a lot to learn which I couldn't find in a web page. I made the decision shortly into my Junior year of high school when I was taking AP Computer Science. I enjoyed studying the subject so much that I couldn't imaging studying anything else.

>What is something that you wish you could change about your current programming instruction?

My current programming instruction is great. I generally think that my professors are very interactive and experienced in their fields. Something I think is great is that most of my professors lecture without computers. They write code on the board, which gives them much more freedom to move about and ask questions, and it makes that classes interesting. I also think it removes the focus from the language being used and places it on the theory, which is the important part.

>Do you look for career preparation or support? If so, what have you been looking at or what resources do you use? To clarify - I mean interview help, prep questions, advice, etc...about preparing to enter the field.

One of Northeastern's greatest tools is its coop program. Typically students graduate in 5 years with 1.5 years of working experience over three 6-month coops. In preparation of this, I had to take a class to prepare me for applying to companies. The experience was amazing. The advising department brought in employers and other students to talk to us and do mock interviews. As someone looking for their first "real" job, this is invaluable. Technical questions are an important part of the application process, but for entry level programming jobs they aren't too difficult. I've heard that is a great resource.

>For those of you still in school/learning - do you worry about how you will find a job programming? What concerns do you have?

Nope, already got my first job in the field. From my experience over the past semester of interviewing, it you're excited about the field and have a reasonable ability to program, you can find a job somewhere (especially if you live in a city.)

>If you're out of school and in the workforce - do you ever worry about how you will move forward in your career?

Not there yet.

>Does your place of employment (you don't have to tell me who) provide you with feedback or a clear path to advancement? Tell me about your concerns here.

Not there yet.

u/Gropamming · 2 pointsr/learnprogramming

Sorry for getting back to this so late, it's been a long week.

  1. You will need a good understanding of HTML/CSS, mostly how to manipulate and traverse the DOM tree. Luckily, this is very simple and straightforward once you figure out how the pieces fit together. On top of that, Javascript does a great job of hiding the need to actually write HTML or CSS markup, though you should still understand how it works. The better you understand the pieces of the puzzle, the more interesting and creative graphics and visualizations you can create!

  2. The graphics are very easy to show off, seeing as they live on the web :) There are a ton of ways to host graphics, either on your own website, or on one of the many free online platforms like Github and CodePen.

  3. As far as preserving interaction outside of the web, I do not have any knowledge of how to do that with Javascript (not to say that it doesn't exist).

  4. As far as resources, I highly recommend reading Javascript: The Good Parts to understand how the language is put together, why it was put together that way, and how to take advantage of its unique style. It is a pretty short read. As far as learning visualizations, I learned most of my fundamentals from taking courses on Lynda, and then used good old Stack Overflow to figure out how to create the specific things I wanted to do in my visualizations. Other good sources for video tutorials are Pluralsight and sometimes Youtube.

  5. YES! That is the beautiful part of creating visualizations on the web, you can power them with any web technology. Most of my visualizations retrieve data from some web API and use that to build graphics or show an interactive dashboard, meaning they look different every time I load them up. This gives you a ton of freedom and flexibility to create graphics that are both pretty AND useful. It's very common to hook them up to databases to query and display data.

  6. As far as IDE's, I absolutely love Visual Studio Code if you have a Mac. It is VERY different from regular Visual Studio and has some great features like a built in terminal window, built in git support, a very lightweight directory structure, and a good community for 3rd party add-ons. It was built with Javascript in mind but I now use it for C++ and Python as well. If you run a windows, I use Sublime Text 2 which has many of the same features. If you want something with a bit more out of the box, Atom is a good IDE that lets you view your site as you build it and also deploys a small web server which is useful if you are not running your own.
u/VerticalDepth · 1 pointr/learnprogramming

CompSci covers a wide range of subjects, many of which won't be that relevant to you. When I was at Uni my classes covered:

  • Algorithms
  • Functional Programming
  • Architecture and Design Patterns
  • Ethics, Professional Issues
  • Artificial Intelligence
  • Compilers and Programming Language Design
  • Data Structures
  • Database Systems
  • Networked Systems
  • Operating Systems
  • Discrete Mathematics
  • Low-Level Systems and Hardware

    This list isn't comprehensive, but covers most of the main points. For your job, you can happily ignore most of that core.

    I think you'll want to focus on with the highest priority:

  • Design Patterns (Book Suggestion)
  • Algorithms (Book Suggestion)

    Warning: Algorithms is a heavy and dry book. It might not be a good recommendation for a beginner to be honest.

    As you're interested in Data Science, you're already off to a good start with R and Matlab. Python is fine but has some issues that don't make it ideal for large-scale data processing. The good news is that once you've got the hang of Python, you can learn another language much easier. I think it's worth noting that R is quite obtuse in my experience, so if you get your head around that you're doing quite well.

    But I digress. You're also going to want to learn about data structures, networked systems and databases, especially if you want to work with "Big Data". I think thought that your best starting place here is learning how to code. With that under your belt along with your math degree, everything else should be easy enough to learn on a case-by-case basis.

    Source: Masters & PhD in CompSci subjects. Good luck, and feel free to PM me if you're interested in a mentor for this. With a better understanding of your position, I could probably help pare down what you need to study to more specific subjects.

    PS: Assuming you're at Uni, your library should have both books I have suggested.
u/FifteenthPen · 15 pointsr/learnprogramming

C++ Primer is amazing, but definitely not for beginners. Since you're totally new to programming, I'd suggest learning a bit of Python first to get the basics down, or if you're feeling more adventurous, pick up a copy of K&R's "The C Programming Language", as it's a great introduction to lower-level programming, and it'll make C++ a lot easier to understand.

Some good freely available online Python books:

Invent With Python

Learn Python the Hard Way

Learn Python the Hard Way is easier than it sounds, I assure you. I would definitely recommend starting with Invent Your Own Computer Games With Python, though.

A couple more useful things to know:

  • If you don't understand something, Google it. Stackoverflow, especially, tends to have a lot of good discussions on common pitfalls encountered by newbies.

  • If Googling doesn't clear it up, don't be afraid to ask for help. This very subreddit is a great place to do so when you get particularly stuck!
u/ChemistInDisguise · 2 pointsr/learnprogramming

I think I get what you're saying, and I was in a spot like this for a while myself, although for me it was more about trying to figure out "how do I debug my code?" - everything's focused on the language itself, and not so much on the peripheral skills. I eventually found resources that helped and I started making progress, so let me pass on some advice.

First up, if you're getting stuck with your IDE, trying getting rid of it for a while. Instead, just use a text editor and invoke your compiler and run your programs through the command line. This will force you to figure out what you don't understand about the build process, and once you do begin to understand it and grow beyond it, you'll be able to go back to your IDE and more easily figure out how to do all the new stuff you just learned in there. The other benefit is that after a few rounds of compiling godawful novels of commands to include and link everything in a decently complex project, you'll be desperate for a better way and have a motivation to learn about Makefiles (or automated build systems in general) which you mentioned not really understanding, but by this point you'll be intimately familiar with why they were created. To learn about them, Google is really your friend - there are a ton of tutorials online and some of them are decent, along with plenty of templates and such to get you started.

But that's only part of your question, I know. For the more general stuff, I have two major suggestions. For general 'peripheral' coding knowledge, I'd actually recommend Effective Computation in Physics. It's aimed at academic researchers and focuses on Python, but those things don't really matter; the best parts of it are the ones that aren't language-specific or domain-specific at all. Because it's written for people who may be trained as physicists (or biologists, or chemists) first, it works up from ground zero and actually explains things like unit testing, debugging, project organization, version control, and everything you need to have a self-sustaining small-to-mid-sized project, which is what it sounds like you're struggling with right now. My other suggestion is that if you're confronting more abstract issues, like design, you could check out The Pragmatic Programmer, which has a lot of good suggestions for avoiding bugs and increasing reusability and ease of maintenance. It's also targeted at small-to-mid-sized projects, but I find most design books for industry-scale stuff to be almost impossible to get through if you're not actively working on a large design team for a real-world application (though if you need that level of sophistication, there are some options if you poke around Amazon).

Apart from those things, you might also consider directly searching for some of your questions, like "how do I organize a software project directory" - I've found surprisingly helpful mini-tutorials from random university CS sites that way, usually as part of the intro or syllabus for a programming class. Oh, and if you're having trouble even getting started on what you want to do, see if you can't break it down further - make a toy engine that does one thing, then add one more thing, then add something that ties those pieces together, etc...

Anyway, hope something in here helps you, and good luck!

u/SanityInAnarchy · 6 pointsr/learnprogramming

I don't think there is anything you need to cover before the class, if it's a good class. However, I would suggest the following -- not before class, but probably before, during, and after class:

  • If the class goes reasonably well, pick up this book. It's a collection of best practices for Java. You will learn bad habits in class, and this will help. (It's not necessarily the class's fault, it's that Java warps your brain in all the wrong ways.)
  • For Java, learn Eclipse, and learn it well. You may find you prefer other IDEs, but Eclipse is among the most popular, it's open source, and Google builds things on it, like the Android and Dart SDKs.
  • Learn source control. It doesn't matter which you pick up first -- in my opinion, SVN was easier to learn, but Git is the best all around, once you get past the learning curve. And once you learn a distributed VCS like Git, you can use it on class assignments -- which I recommend doing, whether it's required or not. (And always make sure you tell your VCS what to ignore. Like, ignore .class files.)
  • That said, learn to do things without the IDE, so you understand what the IDE is doing for you.
  • Extra credit: Learn other JVM languages, like JRuby, Clojure, or Scala. In particular, learn at least one with a good REPL. This may be confusing, because you're using more than one language at once. But it also helps when you want to explore how a Java library actually works, in real time. I haven't found a good Java interactive shell, which is why I use JRuby's IRB for that.
  • Google any term I used above that you don't understand.
  • My experience with a community college was much worse than my experience with a university. If a university isn't practical, I understand... If it fails you -- that is, if you find yourself asking the professor questions that they can't answer, or if their answers don't make sense, don't be afraid to come back here or to StackOverflow.
  • If the in-class projects aren't big enough, start one out of class! Practice is what makes you a better programmer and better with the language, and the best way to practice is to give yourself a project that you're actually interested in. Work your way up from Hello World, but if you find yourself not wanting to practice, you probably need an exciting project.
  • Don't stop with Java. Learn other languages, learn other ideas. That said, when you find something you're really into, specialize and master it -- but you'll still always need to be stepping outside of that. Keep in mind that your skills in all likelihood will become obsolete. You don't need to chase every programming fad, but you do need to stay on top of the pulse of the programming community.
u/ultimape · 6 pointsr/learnprogramming

The Anti-Pattern###

What you've got here is similar to the "Arrow anti-pattern", but may also be part of the "Redneck conditional" anti-pattern. Its hard to tell without seeing the rest of the code.

Here's an article that covers the redneck pattern. It links to some great resources for fixing the Arrow issue at the end. This Youtube Presentation: The Clean Code Talks -- Inheritance, Polymorphism, & Testing and a pretty good overview on Coding Horror: [Flattening Arrow Code](

This Is Normal###

I end up with this pattern a lot on my first pass through prototyping a program. Sometimes its faster to write something quick and dirty - generating code as you think of it (redneck conditionals and all), then go back through and pull out redundancies and rework things to avoid !isTrue lines and other less than good code.

I think this has to do with how spoken language needs to be compiled into thought 'just-in-time'. We front-load our conditionals simply because the mind is not good at keeping more than a page full of words running at any given time. Its only natural to think about problems this way.

This is why languages like Perl and Scala appeal to me - it lets you say things like "do this thing, unless that" and sometimes feels like poetry.

Let it Haunt you at Night ###

Never be comfortable with code like this. Good developers strike a balance between writing good code, and shipping code.

Being a great programmer is 90% sweat, and another 90% discipline. Taking pride in your code means you don't release what you've written into the wild unless there is a good reason for it. If you can help it, don't let prototype code become production code. When in doubt, go with the mantra of "fuck it, ship it", but don't sweep bad code under the rug. Ignoring the problem of technical debt will come back to haunt you one way or another..

And remember: "Always code as if the person who ends up maintaining your code is a violent psychopath who knows where you live."

Why It Is Important To Fight It###

If there is never time (or demand) to clean up this awful code, all you end up doing is building up technical debt, eventually leading to the lavaflow antipattern and other more disastrous patterns.

My rule of thumb for keeping things DRY is the rule of three.

Do this enough, and in time you will start to see opportunities to rewrite your code as you do it. Basically you start to think like a programmer and metaphorically 'speak the language'.

What Happens When You Don't###

Fighting this way of programming is what elevates a good programmer to a great programmer.

The truth is that this is the default/naive style that comes out of procedural programming. You can become so good at this style of coding that you become an Expert Beginner

These expert Cowboy Coders look amazing to management. They able to sling code around fast and brute force their way through code like a mad man. Many 'expert' programmers, even ones who've been in the industry a long time, fall back on copy/pasting code so often that when they end up copying the same bug through out their codebase they don't even take a second thought. This style of development seen normal to them, and being riddled with bugs is just the cost of doing business.

Entire organizations can find themselves full of these types of programmers to the point that the culture shifts from wanting clean code to one that ends up being little more than a drawn out death spiral.

From my experience, this style of coding is very easy to do in languages like COBOL and FORTRAN and can be the default style in larger codebases that were minted before Structured Programming took hold. This lead to the often quoted line by Dijkstra: "The use of COBOL cripples the mind; its teaching should, therefore, be regarded as a criminal offense.".

This can lead to organizations shooting themselves in the foot and losing their best programmers. The codebase becomes riddled with bugs that seem to be near impossible to stamp out, and the ticket workload becomes so intense that you end up with the Crunch Time organizational anti-pattern just to fight the effects of technical debt. I can't see a self-respecting programmer lasting long in such an environment.


I've been trying to find organizations that are passionate about their code quality, and serious about their company culture. If you know of one, please let me know.

u/Soreasan · 4 pointsr/learnprogramming

I would cross-post this to /r/cscareerquestions since that's the subreddit that's more career focused.

My recommendation is to start building a coding portfolio. Specifically set up an account on and start posting some of your projects there. Basically how github works is after you set up an account you download the client and create a folder on your computer. Any code or documents you put into that folder and then "push" will appear online. This will allow you to have lots of code samples to show a prospective employer. Another good idea is to build your own website. There are a couple of good web hosts such as and I personally use because it's very very cheap. (You pay only for what you use and since your website will primarily be used to show employers it will be a few cents a month.)

Once you have a website and Github you'll also want to start studying more and learning more and then creating personal projects. There are a lot of good places to continue learning programming. You could sign up on for their $29 a month plan and then follow along with courses. Alternatively you could buy books about programming and go through them and upload code samples to Github as you go through them. (A strategy I use is to look at books on and buy used copies or copies that are 1 edition older than the current edition, it is very realistic to get books for $4 including shipping and handling.) There are also many free resources such as

Some good books you could buy that will help you once you get job interviews are: Cracking the Coding Interview, Programming Interviews Exposed, and Elements of Programming Interviews. Out of these books "Programming Interviews Exposed" is the best for beginners while the other two are more meant to get you ready to interview at huge companies like Google or Microsoft.

As far as projects to do just pick some ideas and implement them. For me personally I made a website ( and created my own blogging software. There is better blogging software out there then the stuff I wrote for myself but it beefs up my portfolio and gives me something to talk about in job interviews. One idea may be to make some sort of CRUD application/website. CRUD stands for CREATE, RETRIEVE, UPDATE, DELETE. Since a lot of what we do as software developers is data manipulation you can create some sort of app or website that creates and manages information. In my case the first CRUD thing I created was a comment section using PHP and MySQL. Literally all it did was allow people to post comments on a website and then a SELECT statement would display all the comments that people had left. You could do a similar project. The cool thing about CRUD is that you can build apps using a huge assortment of technologies. You could create a CRUD app using ASP.NET, server side Java(JSP), PHP and MySQL(the LAMP stack), or a bunch of other technologies.

Also a huge thing is to apply for jobs even if you don't feel very ready. Check out this YouTube video in particular. Employers put down a wish list of things they'd like in a candidate but know in advance they won't get everything they'd like. If you seem like someone that could learn the technologies they may hire you even though you don't know everything yet. Also you'll want to apply to a lot of places. I've had 15 job interviews so far (I'm graduating this next April) and I have no job offers yet. This means I have to apply to even more places. Even though Computer Science is a very high demand field job hunting is still hard and you still need to put out lots of applications.

u/aha2095 · -1 pointsr/learnprogramming

There aren't many uses for HTML other than web development and as for the last question read below.

Well what do you want to do?
Web development? W3Schools

Note: There are issues with W3Schools as seen on W3Fools but It's a good resource nonetheless.

If so back end or front end? (Simply front end is client side scripting and CSS/design and back end is server sided scripting, if you need more information about these take a look at some of the links and search Google)

If back end try something like PHP, it's a nice language and is quite straight forward. PHP | W3Schools

Simple installers --> WAMP Server | XAMPP

IDE --> PHP Development Tools

If front end then really you need to learn JavaScript. W3Schools | Mozilla resources
(JS can also be used for the back end Node.js)

But for both you need to know HTML. W3Schools

Do you want to make computer programs?
Then maybe stick to something like Java. Oracle

IDEs --> Eclipse | Netbeans

Or do you want to do both?

Then Python would be a great start.

Video tutorials The New Boston

Courses Udacity | Codecadmy

Java paid resource: Java headfirst

There are also recommended resources to the right also maybe head to your local library --->

I hope that helps you decide on what you want to do, I would provide more links but I think that should suffice.

And it should be noted that languages are all very similar so no matter what you should be able to apply what you learn easily so just start where you want to and if you want to expand from say web development to programming it should be an easy transition.

EDIT: Added a small amount of information.

u/cogman10 · 75 pointsr/learnprogramming

HTML and CSS are pretty simple, I would spend almost no time reading about them (Unless this is for some sort of job interview) for the most part you will just be googling "How to I make round borders" until you can do it by rote memorization.

JS, on the other hand, is a tricky beast. I would spend a majority of my time learning not just how to write javascript, but how to write good javascript.

javascript the good parts and Javascript garden is where I would start out learning. Javascript is easy to write, but hard to write well. You need to follow strong conventions otherwise your code will end up looking like spaghetti right quick and in a hurry. If you start playing around with the language, I would suggest using JSLint to make sure you aren't doing anything stupid.

After getting a good strong base in javascript jquery shouldn't be too hard. It is just a javascript library. perusing through the docs and getting a feeling for what it can do is probably all you really need. Just like any library you've used. You didn't learn all of the .Net framework, rather you would google and lookup specifics as you needed them. That is much the way you are likely to use jQuery. It can do a lot and you don't need to know everything it can do to use it effectively.

In short, javascript is where the traps are. The other things you mentioned are "I'm going to google this anyways" so I wouldn't really spend a large amount of time learning them.

u/katyne · 2 pointsr/learnprogramming

Head first Java is what got me out of the woods in less than a week. It's broad and doesn't go into many details but it makes things stick in your head. Effective Java will fill in the blanks. (older editions of the book are available on the internet).

As in for problem solving - don't try to solve the entire problem at once. Break it into simple tasks. Don't start with the main challenge, start from small and simple things. Imagine someone already solved the hard part - make a method to accept the input and format the output. Leave the solveMe() blank for a while. Once the prep work is done, think how you're gonna arrange your input to be processed by the solving part - will it be a map, a list, a custom structure? If so, create that custom class, complete with getters and setters and other convenience methods you think might be useful.

When approaching a solution, first of all, think if it reminds you of some algorithm you had learned before, some homework problem, or another challenge. If not, try to present the challenge in more general terms, like if they talk about sorting apples by color and weight think sorting numbers, etc. Then google it, but don't try to copy and understand the complete solution on SO, instead look for references to an existing algorithm - there always is, these challenges are just slightly decorated common algorithmic problems. Then go to wiki and read about it.

Also, /r/dailyprogrammer marks challenges "Easy" not because they can be solved by a complete beginner with no experience, but because the solution requires little advanced analysis and optimization - like bruteforcing. They're not always simple. If you want something light and truly simple, like a mental workout, try - they have a Java section ranging from very simple to slightly challenging :] Don't get discouraged and again I really recommend the Head First series, as well as reading through Data Structures and Algorithms course (I did Berkeley's CS61B which by the way was how I found out about the Head First book :])

u/bookingly · 2 pointsr/learnprogramming

I don't know what your background is, if this is your first object-oriented language or what. I have gotten a better understanding of programming over the last couple of years, so I may not have the best recommendation, but to refresh on Java, I have found these videos from [Cave of Programming] ( to be pretty awesome.

Very simple, incremental videos that illustrate basic and fundamental concepts pretty clearly for me. Note that there are not quizzes, but by manipulating the programs provided and really making sure one understands what the speaker is presenting, I think one can get a basic understanding of some key aspects in Java programming. If you enroll in the course in Udemy, you may be able to get feedback (haven't tried though to be honest; the course is also free on Udemy).

That said, it wasn't until I started taking some C that I found I understood the Java better; there are some things happening under the hood with Java that I never quite understood until I got to a lower level language like C (and maybe it just took that much exposure, repetition for it all to click).

I took a university course in C, but I am going through a Udemy course on C by Huw Collingbourne that may give a decent overview.

All that said, I do find that I like a mixture at times of watching somewhat more shallow expositions like the video series listed above, but then also enjoy finding some written resources that go into a bit more detail. Check out the Java tutorials for Java. For C, there is [this] (, which was written I think by the two main guys behind the programming language itself.

u/jcbbjjttt · 3 pointsr/learnprogramming

I've been programming for 23 years now. I was originally self taught and have worked with many people who are self taught. In my opinion, working with people who are self taught is usually a much better process than someone who has only ever learned from school based assignments. Since you were never told otherwise but you are super motivated to make things work, being self taught can definitely leads to many bad habits.

For example, the very first game I wrote was in BASIC and I didn't know about loops or subroutines. The entire logic of the game was written using a 10,000 line block of if elses which described all possible ways the game could play out. However, I did eventually learn about subroutines and loops and am constantly looking to improve my code. That is the key piece that you need to remember and put forward when working with others. Let them know that you're always looking to improve yourself. Try not to get defensive about your work if it is criticized. Instead, explain why you chose to do something that way and ask for suggestions on improvements.

It sounds like you're on the right track already and that given time, you'll be a top notch hacker. Keep pushing yourself to improve and refactor your code.

Two books that could be useful for you to start with writing / rewriting code to be cleaner and more professional.

Clean Code
Refactoring: Improving the Design of Existing Code

Best of luck!

u/jj2parkie · 1 pointr/learnprogramming

I started programming in Java few months ago to develop Android applications. These are the resources I used:

  • Java 8 Pocket Guide: This book is very short in length and paper size. It is great to learn the syntax of Java 8 really fast with a general overview of the core libraries in Java SE 8.
  • Effective Java (2nd Edition): After learning the syntax of Java 8, this classic book discusses the best practices of using the Java language in a list of around 78 items. For example, "Item 1" is "Consider static factory methods instead of constructors", and then it explains why.
  • Java Concurrency in Practice: This book is also another classic which a lot of people use to learn concurrent programming for the Java language. It's a difficult book for me: very technical.
    • Introduction to Rx: Netflix has ported the Reactive Extensions library from the .NET platform to the JVM which you can find here: RxJava. It's Wiki with their marble diagrams are amazing. It allows a lot of the new features of Java 8 such as lambdas to utilize functional reactive programming for the Java language. It's all about Observables, and it's main purpose behind its development was to allow the Netflix team to prevent everyone from reading Java Concurrency in Practice as it trivializes concurrency especially for medium to large systems.
  • Clean Code: A Handbook of Agile Software Craftsmanship: This book is also another classic. It uses Java I believe for the examples. A lot of people love this book as a higher level supplement to Effective Java (I think) because it covers best practices for the Java language in designing code for emerging systems or scale-able systems and other topics like TDD.
  • Design Patterns: Elements of Reusable Object-Oriented Software: This book is the classic book (emphasis on "the"). It lists a lot of design patterns which you can use for languages like Java or others. The samples are written in C++ so since you have an experience with C, it can help. I loved this book for learning about Factories, Singletons, Decorators, Observers, Adapters, and more. Using design patterns really helped me solve design problems in my Android application so that it can be easily refractorable.
  • Introduction to Algorithms: The classic standard algorithms and data structures book I suggest if you are not familiar with them. Knowing the concepts can help fine tune your applications performance wise even if you do not implement any algorithms or data structures yourself.
  • Software Engineering: A Practitioner's Approach: A kind-of classic book about the software engineering profession. Its five parts are the following: "The Software Process", "Modeling", "Quality Management", "Managing Software Projects", and "Advanced Topics". Along the way through the book you gain a general understanding of how to write requirements, UML diagrams, and the like.

    All of these books except for the first are near 400 pages each. However, most of them do not require you to read all of it. It would be great to read them entirely, but you can still make do by reading the sections you need the most. A lot of the books listed as classics are books I found that a lot of universities use as I was browsing some curricula. This list focuses upon general programming as I believe mobile development and web development are just learning how to use frameworks which I consider trivial to learn generally since a lot of people say that if they work a place that uses framework X, their workplace gives them some time to brush up or get up-to-speed with the framework and how to use it over a few days unless you require a niche or complex solution to a problem.

    If you are not a huge fan of books, searching these titles will probably provide online tutorials or videos. The Amazon links can provide great reviews and suggestions. I like the books even if they are a bit long because of their professionalism, review, and rigor associated with the publication process of these textbooks that inhibits the rise of bad habits which might be introduced by online sources.

    I do not know your background with these topics, so you may already know the, but these are the resources I think which really helps people transition from just knowing syntax as "knowing a language" which they translate to "I'm proficient in X because I can write a program which allows you to save text to a file" to knowing a language regarding software engineering concepts which helps you work properly on projects medium to large projects you would find in a workplace as an intern maybe entry-level employee (but more formal education might be required).

    However, I'm pretty much like a high school student (took a year off before starting college to recover from an illness), so take my advice with a lot of salt, but these books which I couldn't apply 100% helped me make a small-medium sized Android application: which was designed enough to allow me to manage refractoring to introduce new features or fix issues which I believe would have been impossible if I hacked my way through to write around 35,000 lines of code.
u/Adams_Apples · 1 pointr/learnprogramming

My recommendation is that you learn the C programming language well before attempting to learn Objective-C. There are tons of online and text resources for learning, the one most used by university C programming courses is this text:

Ideally you should get a copy of this or another good learning text, but again, if money is an issue there are resources online for learning.

Here's a good site with lots of videos:
Also this:

And there are resources online that are totally free as well, although they aren't typically as comprehensive and may require a bit more initiative on your part, a quick google search will give you several examples.

With all that said, I'll go ahead and answer your questions, with the understanding that if you just try to dive right into Objective-C it might not work so great for you. This is going to be over your head, so don't get discouraged by it, just remember, we all started somewhere, good luck learning programming!

> 1.) What is a property?

A property is an attribute that the system automatically creates standard accessors (methods to get an attribute) and mutators (methods to change an attribute). Properties also allow you to specify atomicity (a specifier that guarantees thread safety at a small performance cost) as well as reference strength (strong adds 1 to reference count, weak does not). There is more to them than this, this is just a brief overview answer.

> 2.) Why do you need both a public and private API? How do you determine what goes in which?

Public simply means things that you want exposed outside of a class, whereas private are things that only the class should see. By doing this, you can convey to programmers who use your class how the class should be used, as well as restrict access only to attributes that the user of the class needs. This concept is called encapsulation, and is a key concept in object-oriented programming.

> 3.) What is an argument?

An argument is a variable or object that the calling function supplies to the called function. It is the primary means of passing information from one function to another function.

> 4.) What is a heap and a stack? What does it mean when objects "live in the heap"? (Do they live in condos? Is it a quaint suburban community?)

The heap is a block of memory that can be allocated as a program is running. In Objective-C, all objects reside on the heap, because of the way the Objective-C runtime works. In contrast, the stack is statically (compile-time) allocated memory. Primitive types such as int or char are statically allocated.

> 5.) So classes are the .h and .m files in Xcode?

The files with the .h extension contain the interface of a class, which is the file that other classes using this class import. The files with the .m extension contain the implementation of a class, which is where the details of how a class's methods are outlined. This separation exists to simplify linking of files when a program is compiled, as well as to facilitate precompiled libraries (where only the header is visible as source, the implementation is provided as a binary).

> 6.) What do all the differet colored text in Xcode mean?

In Xcode, go to Xcode > Preferences > Fonts & Colors

> 7.) Why are some things capitalized and others are not in Objective C code?

As you learn programming, you'll learn that good programmers adhere to conventions when writing code. The specific reasons why things are named the way they are will come to you as you learn, just bear in mind that good code that follows recommended guidelines is easier for other programmers to work with, your colleagues will thank you for doing it right!

u/JustJolly · 1 pointr/learnprogramming

I just graduated with a CS degree, but here are some resources that I found useful:

  • I'm currently reading this book. It's commonly recommended and I now know why. Great resource for building a solid foundation of SE knowledge.

  • Algorithms are always important. This class and lecture series, along with the recommended text book for the class are really well done. I own the text, it was well worth the money for me. There are other free algorithms classes (i.e. Coursera), but I found these lecture to be the best, YMMV.

  • Lastly, this is the class that goes along with the SICP book mentioned previously.

    I learn best by incorporating a variety of mediums - watching video/lecture, reading books, doing examples by hand/programming. I recommend looking at some of the Coursera classes, other classes on the MIT open courseware, edX, or Udacity.

u/kyle_m_adkins · 1 pointr/learnprogramming

Code is also a good book. If you want textbooks:

This is a good one for computer architecture. And there's a companion course/website at

I like this one as far as operating systems go:

For learning programming, I would check out courses at But be mindful of ratings & reviews because the quality of courses can vary pretty drastically. But I've had good experiences there. also has great courses. They offer paid nanodegrees but you can take every individual course free of charge. is another good website

If you're interested in networking, this is a good book for starters:

Any A+/Network+ certification books or courses would also be a great way to learn networking and computer hardware

Those are pretty big topics in tech & computer science. There's a ton of stuff to learn. I've been studying this stuff for probably 2-3 years and sometimes I feel like I've barely scratched the surface. Let me know if that helps & if there are other topics you'd want book recommendations on! :)

u/faintdeception · 11 pointsr/learnprogramming

The amount of planning you have to do scales with the complexity of the project.

Professors drill the importance of planning, documentation and unit testing into students because it is extremely important and once you start your career if you're a poor planner it's going to come back to haunt you.

However, when you're working on a simple project that's not intended for public release you don't have to go overboard with docs unless you just want to practice.

My own process usually starts with me jotting down an idea; I find that writing it out helps me to get a better grasp on the overall feasibility.

Once I'm satisfied that I actually have something I can implement I'll diagram the flow of the application, and maybe do some wire-frames.

I usually find that this is enough of a launching pad for a simple personal project.

Professional projects are a different ballgame, because as I said, the amount of planning you have to do scales with the complexity and size of the project. It's in the professional environment that all of the things your professors are teaching you will become really important.

So, to answer what I think was your question,

>So how does one end up with 20 classes connected with each other perfectly and a build file that set everything up working flawlessly with unit test methods that check every aspect of the application?

This comes about more in the implementation phase than the planning phase. I've heard it said that in war "no plan survives contact with the enemy" and you'll find this to be true in software development as well. Even when you plan really well you'll sometimes have to go back to the drawing board and come up with a new plan, but that's just part of the process.

Some books that I recommend on the topic are Hackers and Painters - Paul Grahm and I think every software dev should have a copy of Design Patterns

The former is a collection of essays that might give you some useful perspective on the process of writing software.

The latter is more of a reference book, but it's helpful to become familiar with the patterns covered in the book so that you don't find yourself re-inventing the wheel every time you begin a new project.

As for the other part of your question (apologies for addressing them out of order)

>My new "bottleneck" writing code is the structure. I end up having huge classes with way to many public methods. I might as well just write a script with everything in one file. Almost anyway.. I try to write OO, but I often get lazy and just end up with not very elegant systems I would say.

Don't be lazy, because as you're already seeing, it comes back to bite you in the ass.

As you're writing your code you have to be mindful of the complexity of the project as it grows around you, and you have to periodically take a step back and look at what you've created, and re-organize it. This kind of goes back to what I was saying earlier about no plan surviving enemy contact.

So when you find yourself creating a new class that you hadn't thought about, be mindful of where you put it.

Should you create a new file (yes, of course you should), new folder?

Do you have a bunch of similar classes doing the same thing? Should they inherit from one another?

Be especially mindful of copy and pasting from one are of your code to another, generally speaking if you're doing this you should probably be writing a function, or using inheritance.

It's up to you as the developer to make sure your project is organized, and now-a-days it's really easy to learn how to best organize code by looking through other peoples projects on github, so there's really no excuse for it.

Hope that helps, good luck.

u/ziptofaf · 2 pointsr/learnprogramming

Honestly your question is almost irrelevant of programming language. Still, few pointers:

  • Don't mix up database layer with logic and front-end code (if any). Separate them. You can read about MVC for starters. This way you don't end up writing math functions in the same place as you write code that handles a user clicking a button. This ensures your project has a proper structure.
  • Write tests. If you think it's QA department's job to ensure your program is correct (or even worse, if you think that it compiling is good enough) then you are very mistaken. The more tests you write for your program (checking if functions output is correct, if it handles edge case scenarios or invalid input properly etc) the better.
  • Classes are supposed to make code easier to read, not harder and they should be about one specific task. GraphicsHandler that generates a whole 3D grid, has like 20 prototype different shapes you can put on said grid etc is NOT a good class design. Those have to be simple. If you start seeing shitloads of methods in a class to make it work then it means you need two classes.
  • While on the topic of classes - group up your methods by their importance. Don't shove most important ones at the bottom. If you know a method won't modify your arguments then declare it as const. Also - multithreading is a big thing nowadays. If you KNOW your method won't work with it properly and is all but threadsafe then write it down somewhere. Or add a mutex so it can't be ran by multiple threads at once. Especially important if you are writing a library.
  • Be consistent. Nobody cares if you prefer tabs or spaces, just decide on one. Often it's project manager or company policy itself that defines it but as an independent programmer you need to learn those habits by yourself. If you decide to use camelCase notation for methods and functions then don't suddenly write methods_like_this.
  • Practice writing GOOD comments. Often you see programmers either not writing them at all (terrible!) or not understanding the actual point of them (possibly even worse). You really don't need a comment that says "here we loop through an array". But if for example you have a Pixel color in ARGB space defined as a single unsigned int (so you have 1 byte for A, 1 for R, 1 for G and 1 for B) and you manipulate specific colors directly (via bitfields/converting it to char array) then it's a good idea to explain HOW your process works in a comment because it might not be obvious for a programmer if he suddenly sees a union or <reinterpret_cast> from int* to 4 element char array. if what you are doing might not be obvious - write it down too.
  • Also - you have version control nowadays. Don't leave huge commented out parts of your code.
  • Proper naming of your variables. i and j are fine for loop iterations, x and y can make sense for coordinates and a,r,g,b are good names for color values but that's about it. Write all names in a way that means SOMETHING. I very much prefer to see a variable Person new_user("Bob") to Person x("Bob"). Since afterwards I will see a new_user (which makes me think it's probably a User/Person) rather than x (which can be anything, now I need to find a declaration!).
  • Avoid declaring your variables without defining them:

    int howMany;
    for (int i=0; i<howMany; i++)
    In this example it's obvious but often you create a new variable, forget to assign it and 100 lines later try to use it and have no idea why is your code blowing up. Most of the time ANY default value is better than not having it at all.

    And with this I explained roughly 1% of what a clean structure means. There are good resources on that, check out Clean Code book.
u/s1lv3rbug · 2 pointsr/learnprogramming

You are on the right track. The most important to understand is the fundamentals of any programming language. You mentioned Java. Java is an object-oriented programming language. In order to write good code in Java, you will need to learn what is an object? What is object-oriented? Like, what is inheritance, polymorphism, classes, interfaces etc etc. Once you learn the concept of OOP and you want to learn Python (another OOP language), it will be that much faster, because you already understand the concepts. Python has its nuances but you learn as you go along. I think you should start with the Head First series by Oreilly. They are sooo good at teaching this sort of stuff. I will give u the links below:

Head First Java

Head First Object-oriented Analysis and Design

Head First Design Patterns

Buy just the one book and start from there. Checkout the Head First series, you may like other books too. Also, google 'design patterns' and read about it. Some people mention Algorithms and that is all great stuff and you will learn as you write good code. There is another book I would recommend:

Pragmatic Programmer

I would also suggest that you should try different types of programming languages as well. Like functional (LISP or Scheme) or procedural (C). When you do that you will start to think differently and it will expand your knowledge. LISP was created in 1958 by John McCarthy. My friend works at Google and he told me that they are using LISP behind Google Maps.

u/KernlPanik · 20 pointsr/learnprogramming

I'm a ~10 year sysadmin that has decided to rebuild my software dev skills that I haven't used since college. Here's what I did to reawaken that part of my brain:

  1. Harvard's CS50. I figured an entry level college course would be "beneath me" but it was a great experience and I learned a surprising amount. It's very entertaining as well so that made the "simple" parts fun to do as well.

  2. Read CODE by Charles Petzold. Great insight into the nuts and bolts of how computers work. Read through it on my lunch breaks while taking CS50 in the evenings.

  3. Read and do the problems in C Primer Plus. This is a great book for learning how to write in C, which is the basis for all modern languages and is still widely used today. Great starter book for anyone who wants to learn to program.

    3.5) After going through the last chapters of C Primer Plus, I realized that some of my math skills were not up to par, so I took this MOOC from MIT to supplement that. No idea if that's something you need.

  4. Here comes the fun one: The Structure and Interpretation of Computer Programs, aka The Wizard Book. This book is more about how to design software in general, and it is pretty difficult. That being said, if you can get through it then you have the chops to do this professionally.
u/[deleted] · 7 pointsr/learnprogramming

I'm 43 and became specialized in a narrow range of products. on the one hand, if you need someone who knows about this stuff, I'm one of the most knowledgeable you can find.. on the other, I've become so specialized it's starting to hurt me career/ financially.

a friend of mine just got another startup going. he's a backend php developer and they needed more of a systems/ sysadmin person in a part time role to setup all the tools and the production environment. he asked if I'd be into it and I said yes - I was eager to learn new skills and aware I'd be blowing away cobwebs and kick starting brain cells etc. but dived in.

I've learned more in the last few months than I've learned in the last 5 years and it's been awesome. I read and really enjoyed [Code] (, I'm almost finished working through [learning the bash shell] ( and plan on working through [C programming] ( after that.

one thing, I used to be a Java programmer a decade ago. I read computer articles out of curiosity and will buy the occasional computer book for fun.

backing up - I've realized in the last few years that for me one very important skill is the skill of learning. getting your brain back into a state where it absorbs new information easily and likes it can be an uphill climb once you start back after a break of a decade or more.. but I'm resigned to always working on new stuff, deepening my technical knowledge, studying music, I want to do woodwork and organic gardening, learn piano, etc. after a while you start seeing deeper connections between areas of specialization - and that's pretty cool :)

u/N0N-Available · 3 pointsr/learnprogramming

This is one of those questions that basically yields no useful answers.

  • On the how part, it depends. Generally you would analyze your requirements and problem and find out that it fits problems described by one or more design patterns. So you apply these design patterns and modify them as fit until you think you've cover all the basis on a higher level. Now you have a fuzzy picture of the house you want to build and where the general walls and hallways are. You might have kitchen and bedroom marked that you know will be for certain purpose but you don't have anything specific in each room yet(hope the analogy makes sense)

  • Next step will be the more difficult part, which is fine tunning and validating your blueprint. Idk how other people do it, but I prefer to run through each requirements and see how they fit into each "room". This process usually expose ambiguity in the architecture. You want to the repeat the process till it is clear how each requirement will be handled. It's a good idea to also anticipate how the requirements might change or expand in the future when validating your architecture.

  • In the case of Django they basically did most of that for you already. If that's all you work on then I'm not sure what you are asking, you could look into data structures topic if you want better data model designs. Front end is pretty flexible, usually depends on the framework you pick and follow their design style. For server side application that supports your front end would depends on your problem/requirements. Like I said this is one of those questions that yields no useful answers since it's essentially design question and design is very subjective and a broad topic. As far as UML or whatever other tool/diagrams you choose to use, it really doesn't matter as long as it conveys your design clearly and there's no ambiguity.

    Not sure if I answered your question. You can checkout topics on design patterns. there's a good book on Amazon for that I think just called design patterns. Or checkout tutorialpoint.Com ? For software architecture.

    Design Patterns Book

    Software Architecture Quick Overview

    edit: added resources and changed format
u/JumboJellybean · 1 pointr/learnprogramming

Here are my two big enthusiastic suggestions.

Sign up to Lynda. You get a 10-day free trial, and then it's $30 for a month. Watch Foundations of Programming: Fundamentals (4h 47m), Foundations of Programming: Data Structures (2h 29m), Programming Fundamentals in the Real World (3h 8m), and Python 3 Essential Training (6h 36m).

These are short crash courses, you obviously don't walk away a full-on programmer. But the main instructor Simon Allardice is excellent at explaining the basics and fundamentals in a very clear, natural way. I have taken university courses, I have watched MIT and Harvard courses, I have used a dozen tutorial sites and watched a bunch of lecturers and read three dozen books: the Lynda programs I linked are the best first-intro things I've seen. I strongly recommend that you watch at least the first two.

You might not understand it all, that's fine. Don't worry about what languages he uses for examples, 90% of stuff carries over between languages. If you can absorb a good chunk of that material it'll be a huge boost for you and a nice foundation to start on. You'll walk into your first real class in a better headspace, already knowing the gist of what you're going to flesh out and properly sink your teeth into. And if you find that the Lynda stuff really works well, look up their C and databases courses, since you'll wind up using that stuff too.

My second recommendation is that you buy and read Charles Petzold's wonderful book Code: The Hidden Language of Computer Hardware and Software. This book doesn't focus on a specific programming language, or how to implement programs, or the mathematics, or the theory. Instead it answers "So what is a computer actually doing under there when we program? What's a CPU, exactly, how does it understand words and numbers?" It does this in a very natural, accessible, for-the-layman way, starting with really simple analogies about signal flags and morse code, and before you know it, bam, you understand logic gates and binary arithmetic, and a lot of the mystery and magic of computers has dissolved for you.

u/E3FxGaming · 1 pointr/learnprogramming

Wow, 4 years is a long time.
Maybe you simply started with the wrong and especially with too many languages.
I myself made an apprenticeship and learned the basics of Java in 3/4 of a year and after that it was my own desire to advance further. I wanted to learn how to integrate SQL connectors into my code and what I can do with those connectors. So I learned SQL afterwards. After that I learned how to program GUIs with JavaFx and how to develop dynamic generated websites with the Java Swing framework. With this I got the basics of HTML. Please note that all of this was a step by step process.

I haven't used Ruby yet, and my php knowledge can only be described as "I don't want to talk about it", so I can't judge if it's hard or easy to learn, however I do understand from your description that you had a hard time learning those things.

In our modern world, class-based (aka "object-oriented" - short OOP) programming is a key element, so if you want my opinion, no class-based is not the next step, instead I would say it's one of the first steps.

What would I recommend you... hmm, maybe start with Java? It's a highly used language, so if you get what is going on, you will have good chance to get a job. It also helps a lot if you want to understand how OOP works, because Java was basically built around this concept.
I recommend the Book "Head First: Java", I read the german version of it and it was really worth the effort. It clearly explains how OOP works, with examples and a lot of self involvement.

Oh and always stay positive. Being a developer is not something where one day you can say "I'm finally a perfect programmer". Always look back on what you already can do and then look for ways to improve yourself, even if it's not required for your current job. One day you might score bonus points by knowing something that no one else knows and people who score bonus points are always welcome in a company.

u/TurkishSquirrel · 1 pointr/learnprogramming

Interesting comment on compiling it with VS, i tried it in VS 2012 with /W3 and only recieved

warning C4551: function call missing argument list

compiling with /W4

warning C4189: 'asnwer' : local variable is initialized but not referenced

This lack of warnings from the compiler is a bit disturbing heh. Compiling with /Wall spits out a bunch of other unrelated stuff. Perhaps try changing to /W4 in the project properties C/C++ tab.

I'm not surprised that Ask and Say where called a few times, stepping through your code Say i think would be called twice and Ask would be called 4 times. Rough guess heh. The reasons for this are how your code is written

On line 33 you call Operator(), which calls Say() on 22, Ask() on 23 and Ask() again on 24. This call returns and next Operator is called again on line 34, calling Say() again and Ask() two more times.

The issues with the program i believe arise from a lack of understanding of C++, learncpp is an ok site, but really all online C++ tutorials are crummy/mediocre at best. You should pick up a real book, a commonly recommended one for beginners to programming and C++ is C++ Primer Note: NOT Primer Plus, just Primer.

The only reason is that the return type signifies sort of signifies your intentions with what to do with what's being returned. If you return bool, you clearly wish to check if something occurred or didn't. However returning int or char could be used in many more things. What I'm trying to say is that char/int will work, but bool is far superior in this situation.

You could really do with a good book to learn from. If you'd like me to pick over each issue with this program and help you work out a working version I can, although I'll be heading to bed in about an hour and it'd probably be more helpful to get a good book than focus on this one program.

Most important: to truly learn C++ you'll need a good book.

u/ss0317 · 2 pointsr/learnprogramming

Congrats on landing the interviews. I don't have any specific advice, but perhaps pick up the book "cracking the coding interview" and give it a once over. It offers some good technical and non-technical advice that may be helpful.

You're probably right in saying that you're not going to become an expert by reading books over the next few weeks. I think the best thing you can do is gain as much knowledge (within reason) in the areas you think you are deficient in.

The ideal candidate doesn't necessarily posses all of the skills at day 0, they're going to be judging you from a standpoint of whether or not you have the prerequisites to grow into the position as well. You've already proven to them that you have talent. So, in addition to last minute gap filling, also focus on your soft skills and your ability to demonstrate a growth mindset... it may take you further.

u/MeoMix · 11 pointsr/learnprogramming

Hey man. Good to hear that you are interested in programming. :)

I don't think "books" is a good suggestions. There is a lot to read and not a lot of time in the world. Plus, programming tends to be more fun.

That being said, however, I am going to go ahead and recommend reading Code Complete. I think that book should be required reading for every programmer. You will learn a lot and it is also a fairly amusing / interesting read.

I would also like to suggest that you use StackOverflow and follow interesting conversations in it. One of the tricks to programming is to become very engrossed in it. Find things you find interesting and read/learn just for the sake of it. If you think you know language 'X' well -- go to StackOverflow, sort by votes, filter by tag and tag the language you want to read about. I guarantee you will find a lot of "Woah, I did not know language 'X' could do that."

One last thing w.r.t all the 'what languages should I learn' hullabaloo. Start a little higher level. It sounds like you want to learn an Object-Oriented language. Do you know what your other options are?

There's a quick overview of the different 'types' you'd expect to see. OO is a clear one, especially for industry development, but functional languages and others may also end up being used for your job. :)

EDIT: A little more on topic. I started with C++ in school. Some concepts were difficult -- pointers, references/pass-by-reference/de-referencing, and to a lesser extent garbage collection / memory allocation.

The main argument for learning C++ first is that it gives you good fundamentals. Every programmer should know what a pointer is. And a double pointer, for that matter! The main argument against learning C++ is that you can blow your foot off much easier than in Python. And that's no fun. And if you're the type of person who isn't ...tenacious enough to try and repair your own blown off foot -- perhaps a higher-level language would be a better choice. In this way you can become more accustom to the frustrations of coding (and how to cope) before introducing more complex issues.

That isn't to say you can't create just as large a clusterfuck with Python. You can. It has its own nuances. It's just that the library support (code already written for you) is going to be more extensive. A good comparison would be driving an old car vs a new car. The engine is harder to repair in the new car (can't get at the parts), runs better, but you don't get a feel for whats in the engine. Its more of a black box. That old '57 Chevy (C++) has its engine laid bare (not as much as C), but if you're no mechanic you might break your car and abandon it.

Just do what you find fun! You're still young :)

u/Bizkitgto · 7876 pointsr/learnprogramming

I'd start with Harvard's CS50 on edx, it's the best course you'll find anywhere bar none. The instructor, Dave Malan is world class. Check out CS50, and the sub r/cs50 has a lot of like minded people like you. (Note: this course is free)

Stackoverflow is your friend where you can ask any question you have or bounce ideas off of others.

Learn Java OOP (here is an excellent course): Java MOOC

Free Code Camp for web development

Build your own operating system: NAND2TETRIS

Cave of Programming : All kinds of programming

Open Source Society University: This is a solid path for those of you who want to complete a Computer Science course on your own time, for free, with courses from the best universities in the World.

r/arduino for some embedded programming fun!

.....and of course for anything under the sun: &

For BSD:

For Linux:

For x86 assembly: [How far down the rabbit hole do you want to go?]


Edit: Wow, my first Reddit Gold!! Thank-you so much kind people!!

Edit2: Colt Steele has a good web dev course and is highly recommended to do in parallel with freecodecamp

Edit3: The MIT Challenge
is Scott Young's blog on how he completed the entire 4 year MIT Computer Science curriculum in 12 months

Edit 4: The Rails Tutorial by Michael Hartl is the Bible for learning Ruby on Rails

Edit 5: For deeper knowledge of OOP check out Sandi Metz’s POODR

Edit 4: The Bible for C Programming: K&R

u/chhhyeahtone · 7 pointsr/learnprogramming

If you want to know what programming is like, try Stanford's CS101 course. It's very basic but gives you a taste of what you can learn. You can breeze through it in a week or two. Don't worry about memorizing the code, just focus on the concepts.

If you finish that and enjoyed it, you can try M.I.T's 6.00 1 course. It teaches you Python, one of the easier programming languages to start with. This course is longer than the first one and is an actual programming course. It recommends the book Introduction to Computation and Programming Using Python if you need it.

After that, I would say give Harvard's CS50 online course a go. This course teaches you the C language and is easier to complete if you did the first two courses. This course recommends the books: The C programming language book or C programming: an absolute beginners guide for a more beginner friendly (and budget friendly) option.

Good luck and have fun

u/phao · 1 pointr/learnprogramming

I can think of two books that surely can help you. They won't teach you C++ to its full capacity, of course, but I think they can get you up to speed.

  • Accelerated C++ -
  • A Tour of C++ -

    They both teach significant aspects of the language while still being small, which are huge achievements for C++ books. Of course they miss a bunch of stuff. You can't become an expert on C++ on 8 months. But, I'm convinced that these books will teach you more C++ than what you'd learn in most (maybe all) college courses out there (considering of course the ones that teach C++).

    Accelerated C++ will go through key language concepts and facilities so you can start writing significant programs even though it won't teach you many language details. It as soon as possible introduces library facilities in C++ that allow you to write interesting programs instead of going through all the details about everything. It also is focus on teaching C++, and not C then C++ enhancements. In general the book makes a lot of effort to teach you useful C++ in 350 pages, so it focus on things that are generally useful, and it misses things that are also useful but less commonly so.

    Accelerated C++ is somewhat old (2000), which is why I think it'd be a good idea to read A Tour of C++ afterwards. This one is by the inventor of the language. He goes through C++'s features (it covers a lot of them... I'm not sure how much % though). Anyway, it impressively covers a lot of the language in 190 pages. The reason why I'm recommending this one is because it covers both C++98 and C++11, and it also goes into language features the first one doesn't.

    So 350 pages of Accelerated C++ with somewhat easy exercises (none that will require you hours of research as far as I remember) and 190 pages of Tour of C++. I think that can teach you a lot of C++ to code machine learning algorithms given you already know those, of curse =).

    Good luck.
u/enelsk · 3 pointsr/learnprogramming

Are you thinking about this in the context of a particular language or framework? Sometimes that will help steer you as to how you might organize your code on a high level. For example, the Model-View-Controller paradigm is implemented on an api level in Ruby on Rails, and you'll also find it in practice if you build an iOS app.

If I'm working on something that doesn't rigidly dictate architecture, I still like to frame the project with MVC in mind. That means you're going to have classes that make up your data layer, your controller-like classes that implement business logic, and some classes that represent visual representation. Sometimes your views may not be code at all, and it's some type of markup like HTML or XML.
I'm linking this since I'm using it myself as I learn a new web framework, Express. Express isn't very opinionated with how you organize your projects, but I think Peter gives a pretty good explanation as to how to do it with Express, and it could be extrapolated to fit other projects:

For an example of a mature, larger project, Discourse is an open-source web forum. I particularly like how code is organized in this project.

Lastly, if you're interested in a book, look no further than Code Complete. Probably my all time favorite, I make a point to try to re-read parts of it every year. It's a book about code construction, and offers invaluable insight as to how you should strive to organize your code, and more importantly, why you should organize it that way.

EDIT: I should mention I'm speaking with Object Oriented Programming in mind. Of course, if you're using something procedural like C, it's a fundamentally different programming model with routines and functions operating on and transforming data structures. Systems programming, something like a driver, is going to be organized differently. Again, the answer is somewhat domain specific.

u/Mr_Ected · 1 pointr/learnprogramming

One of my favorite books for practicing in C is Data Structures in C (Kalicharan).

I like it because it's good for keeping you up to speed on core data structures/sorting algorithms, it's less than 300 pages which means it doesn't bog you down in maths or academia (though the concepts are still explained very well), but also because it's packed full of exercises. Each chapter ends with ~15+ exercises, some of which are pretty challenging.

I know you're not looking specifically for a data structures book, but this one is pretty good for solidifying C knowledge in a practical way.

Also, The C Programming Language (Kernighan/Ritchie) is a classic that has a bunch of exercises.

Just curious, why are you learning C before Objective-C if your goal is iPhone apps? Don't get me wrong, I love C (it's probably my favorite language), but any fundamentals you learn in C you can probably learn just as well in Objective-C and you'll probably get to your goal a bit quicker.

u/romple · 3 pointsr/learnprogramming

Well, if I were evaluating this in an interview these would be my thoughts:

I don't like one letter parameters like String s. It's pretty obvious here since there's only one parameter and the method name tells me what's going on, but this can lead to unreadable code for larger methods with more parameters.

The 0 length string guard at the start is nice, although necessary here. Unnecessary code makes things cluttered and less readable.

The if(!p.equals(" ") ... statement is unnecessary. When you split the string it should essentially remove any white space. When reading code a lot of time is often spent on interpreting complicate predicates, so it's good to remove unnecessary ones or abstract it out into a method. Unnecessary code makes things cluttered and less readable.

if (!p.equals(" ") && !p.equals("")) could easily be a method isValidWord(p), which lets me read the flow of the statement without necessarily reading the innards of what a valid word is. I can do that later, but right now I just want to understand the logical flow of what's happening. Again here, it's fairly obvious, but when things are more complicated and validation criteria are more convoluted these are good abstractions to make.

stack.push(p.trim()); again seems redundant. There won't be any padding whitespace when you split the string to an array. Removing unnecessary code leads us to

for (String p: parts) {

Also, while we're here, why p and not part? If you're trying to go full on readability, one letter variables are basically outlawed except as indexes.

for (String part: parts) {

While we're still here, why parts and not words? Words is more descriptive of what the variable represents. You always want descriptive variables. The goal of clean code is generally readable code. Although part could be argued as appropriate here. Word just conveys more meaning to me.

I don't know if you were told not to use existing APIs, but taking advantage of existing abstractions makes code more readable in general. For instance

public static String reverseWords(String s) {

List<String> words = Arrays.asList(s.split(" "));
String reversedString = "".join(" ", words);

return reversedString;

Just looking at the above you can pretty much tell what's happening. We have a List of words, we reverse it, then join that list into a string. you can even abstract out more things, but this is probably overboard. But if we go down that route you essentially have 3 lines of code to read to understand what your logic is. Build a list of words from a string, reverse it, then join that list together into a string.

public static String reverseWords(String s) {

List<String> words = buildListOfWordsFromString(s);
String reversedWords = joinListOfWordsToString(words);
return reversedWords;

private static String joinListOfWordsToString(List<String> words) {
return "".join(" ", words);

private static List<String> buildListOfWordsFromString(String s) {
return Arrays.asList(s.split(" "));

Anyway, these are just my thoughts and people will disagree. This is still one of the best books to read if you're interested in writing more readable code.

u/bumhugger · 1 pointr/learnprogramming

It's perfectly fine in an isolated assignment like this, but it's also easy to start using exceptions as a part of code flow in larger software when you are writing programs for a living. And that's when bad stuff might happen, plus it is harder for your co-workers to decipher what your methods are supposed to do.

Effective Java by Joshua Bloch is probably the best book you can read if you want to improve your code. It's not that thick, and it's divided into "items" that are easily read in any order you like. For instance, there is an item about exceptions, just like your case, but probably way better explained than I did :)

Things like this might seem nitpicking, but in my opinion the easier it is to read your code, and the more robust your methods and classes are, the better. Otherwise you produce spaghetti that people have to maintain 10-15 years from now and they will curse their miserable lives every day. I've been there, it really opened my eyes :D

u/ChrisFingaz · 2 pointsr/learnprogramming

Starting this off as saying that I work primarily in iOS and mac environments. I think PCs are great and apple is overpriced but I really enjoy it and I love Swift so whatever.

If you're building applications in Windows most people seem to start with Visual Studio. There's a ton of resources, frameworks, libraries, and a large community for it. At the very least it's probably a good place to start. For C++ development maybe start here:

Now for your broader question of application development, I would start with the Gang Of Four for code design. These aren't easy concepts to get right off the bat, it's putting in some reps before it becomes natural. You'll never use just one either, most projects become a mesh of different design concepts and there's way more than 4. I recommend coming up with a simple project to build on your own and then attempting to architect that from a high level before coding. Then actually building it. It's really the only way to learn. For C++ reading maybe check this out (not 100% on this, I don't do much with C++, but seems recommended as an update for the original Gang of Four):

Another book:

it's from this list:

This all said, don't get bogged down in books. Read enough to feel comfortable starting something then start it.

u/HomeNucleonics · 19 pointsr/learnprogramming

Cracking the Coding Interview is a bestseller on Amazon and is extremely helpful. I've read through it on flights out to interviews, and it puts me in a great frame of mind.

If anything, I get more out of the guide for how to approach interview questions more so than the meat of how certain problems or algorithms work themselves.

Make sure you take the science of approaching your answering process for the questions just as seriously and systematically as the mathematics/algorithms involved. Cracking the Coding Interview does a good job of summarizing the approach you should take, and gives a series of questions to practice answering in the manner provided (all sorts of common algorithms and data structures used in interviews are contained in the book, giving you great practice at applying these types of things). You should buy that book right now, and buy a whiteboard and an erasable marker to practice answering some of the questions on. Well well well worth it.

Most of all, have fun! In a certain way, the more fun you have, the better your impression will be on your interviewers.

Also, I wore a suit once to an interview, and I felt like a moron.

Edit: some quick re-wording.

u/brenninja · 3 pointsr/learnprogramming

32 here, I was a high school teacher for 6 years. I learned quickly that it was not what I wanted to do long term. I started dabbling in programming and quickly fell in love with it. This past year I attended a year-long program (7 months 9-5 classroom, 5 months internship) for full stack web development. I had a well-paying position at a top tech company lined up before completing my program and am very happy with my career change.

My best advice would be to go for it! There is a huge demand for devs and while I understand it is easy to look at your age as a boon many employers will see it as a positive attribute.

  • You have proven from your past career that you can work with other people and handle yourself as an adult. Unfortunately this is not a guarantee for many fresh college grads
  • devs from different backgrounds are valuable as the more diverse your dev team is generally the more accurately it represents your user base

  • If you haven't done so already you might want to open a GitHub account and start putting some of your projects up so prospective employers have something to look at.
  • The online courses as well as bootcamps are great for project-based learning. During my internship I found that the biggest difference between myself as a bootcamp student vs. a CS major was in my lack of knowledge regarding data structures and algorithms. This is where most interviewers will focus their time with you. I used Cracking the Coding Interview to study before interviewing and found it very useful.
  • Use the skills you are gaining from FreeCodeCamp and TreeHouse to work on your own projects (not just the ones they walk you through)
  • Go to meetups and network.

u/stefan_kurcubic · -2 pointsr/learnprogramming

woah! brave young man right here!

how to be developer 101


  1. listen to your gut and trust it (it knows what it is saying and why)
    1.5 find a goal, set schedule and stick to it.
  2. stay healthy. eat regularly, sleep from 10-6, exercise 30min/day (walking is good), drink water
  3. this could be the best thing that happened to you. there is a reason for everything
    if you devote a year to this. you will be ready for a job and since you know stuff already it is going to take even less!!
  5. discipline!!!!!!!!!!!!!!!!!!! do it everyday think about how you can improve, find out about something new, implement new ideas, your calling is to be PROFESSIONAL webdeveloper ACT LIKE ONE.

  6. mindset -
  7. fit more easily in a team -
  8. BUILD BUILD BUILD BUILD BUILD BUILD. you learn by doing not by thinking or reading. put everything on github YOU ARE PROUD OF

    after you complete FCC

    or if you are hungry look here

    write me in a year
u/a_redditor · 1 pointr/learnprogramming

Let me just say right off the bat that it sounds like you're well on your way to being a successful programmer.

One thing I can definitely suggest (which helped me a lot) is reading Code or some other book like it. It is effectively a guide from the ground up of how computers and programming work in general. I had the fortune of reading most of it before I started my CS degree, and it really helped me breeze through my hardware courses.

As well, any books on data structures would probably be helpful, as this is one of the early topics covered in many CS programs. I can't suggest any specific books, but I'm sure others can.

Most of all I have to suggest just getting very comfortable with programming and learning several different languages. It looks like you're already well on your way with this, but the goal here is to have a strong passion for programming before college. That way, when you're up at 3 AM the night before an assignment is due, it's not because you procrastinated and you waited until the last minute to start because you loathe the thought of programming, but because you're so excited about making your code perfect and adding in additional functionality because you absolutely love programming.

u/AlmondRoast · 0 pointsr/learnprogramming

If you're mainly interested in Java, I would recommend Effective Java by Joshua Bloch. It's a great guide with recommendations for best practices in the language.

For C, the best book is The C Programming Language by Kernighan and Ritchie. I would recommend that you read that before ever looking at C++ because C++ is based on C. In fact, it's such a great book that I would recommend reading it before you read anything else on any language. You can skip the file system and Unix stuff though.

For C++, I have never found a good beginner book, so my suggestion would be that after you read the above C book, read the stuff in this tutorial and then read Effective C++ by Scott Meyers. It's another best practices book.

For Python, I've heard good things about Learning Python but I don't really know. I actually found it more useful to just go through the Python tutorial and then start making fun little scripts.

Hope that helps!

u/sixfootGeek · 1 pointr/learnprogramming

Hello! I had this exact problem, plenty of syntax books etc but I wanted to know why things were being done the way they were being done. So I asked my CS lecturer. He recommended Code complete.
Its a fantastic book and I found when reading a section that I found interesting it would have side notes recommending other pages that expand on that particular topic in greater detail. Which is awesome, best money I've spent on a book since Harry potter and the philosophers stone ;)

u/haxifix · 2 pointsr/learnprogramming

I completely agree with your observation that programming is more of a way of thinking than it is about knowing the syntax of a specific language. Yes, we may all have our preference or most used language, however; any programmer is going to have multiple languages that they know and it also is usually not difficult to pick up a new language once you're a programmer for that exact reason.

That aside, a quick google search brought this book up. I do not have this book nor have I read it, but it seems like a decent book for $15. Remember, there is no substitute for solving problems on your own though. The book may give you insight and hints and may give you a list of challenges with solutions, but you can also improve your problem solving skills by just googling "beginner programming challenges" and attempting to solve some of them.

Hope this post helped you, if you have any more questions feel free to ask or PM me :)

Best Regards,


u/boojit · 5 pointsr/learnprogramming

Ok here goes.

One of the challenges with answering your question directly is deciding at what scope to answer it. If we take your question at its broadest level of meaning, it almost becomes "how do computers work?" What I mean by this is when you said in another comment that you'd like to see how a program goes from outputting simple text into a command window, to a program with a GUI like Audacity, you should be asking yourself, " does the program output to the console?" And for that matter, how do the characters get drawn on the screen? What is happening when I "compile" code into an executable, and what happens when I "run" an executable?

So you see how this can quickly get out of hand. One of the things that is frustrating with starting to learn how to program, at least it was for me, is you get sorta plopped right in the middle of the story. Typically, you don't get the beginning of the story until much later in your studies.

And that's because the beginning of the story, while very interesting and well worth knowing, is pretty damn complicated. It takes quite a bit of study and effort to wrap your head around.

But let me whet your appetite anyway. Since we have been talking about input/output (console output vs. a GUI), take a look at this page. What you have here is a very, very, very basic computer. It doesn't have a monitor, and it doesn't have a keyboard. It doesn't have a disk and it can't connect to the internet. But a computer it is, and its fundamental operation is exactly the same as the computer that is your laptop, or tablet, or smart phone. The way you input information into this computer is by flipping switches on the front. The output from the computer is displayed on the little LED lights on the front. But at a high level, it's not really that different from what happens on your computer: you input information into the computer that you want processed, the computer processes that information, and the output of the processing is displayed to you.

Watch the video on that page, and you'll see what I mean about even though this computer is primitive compared to your laptop, it is still quite complicated. I don't expect you to understand what he's talking about in this video (you will later as you progress), all you really need to take away is this idea that even with a primitive computer like this, explaining how you input data into it and get data back out of it, is fundamentally a complicated thing. If this sort of thing interests you and you would like to know more, I would recommend you pick up this book.

Here's the point I'm trying to make: you won't get a truly satisfying answer to your question until you understand how the toggle-switch-blinkenlight computer works, for starters. Obviously, that won't be for a while. And that's OK! Just understand that you're kind of starting somewhere in the middle of the whole "how computers really work" story, and know that eventually you will read the beginning.

Now to your specific question.

First I think reading this page will do more to put you on the right path than anything else I could say. Therein, the author will show you some very basic Java GUI programs that you can run yourself, even if you're not using an IDE. In one sense, programs like Audacity are just more complicated versions of these primitive GUI programs. So that is off to a good start.

But what this author doesn't really address is how when you write JOptionPane.showMessage, how the computer takes that line of code and is able to go "Ok, um i am now going to draw a box on the screen and make this thing called a button, etc etc".

So what's going on there? As some others have pointed out in various comments, there are things called APIs that Java can access; these are libraries of code including the code to draw those windows and buttons on the screen, made such that YOU can reuse that functionality in your own programs without having to write it yourself. Also others pointed out that you have something called an operating system or OS; similarly this provides a sort of "platform" for your code to run on; so for example you can ask the OS to load a file from disk, read from the keyboard, etc, without having to write that code yourself.

The major point here is that other industrious individuals have spent a lot of time writing tools that your little tiny program can leverage. Even the simplest "hello world" program is relying on all these tools -- otherwise the code wouldn't look so simple!

I hope this helps. Please let me know if any of this is unclear, I'll try to clarify as my schedule allows.

Edit: spelling, grammar, tightened up some sentences

u/Tyaedalis · 2 pointsr/learnprogramming

I just began reading CODE and it talks about the lowest level of computing mechanisms. This could be something of interest, although it wont teach you how to program specifically.

For that, I propose to you -- as others have -- Learn to Code the Hard Way. I would recommend the Python version, but he is working on a C version that is being completed. Another great contribution is How to Think Like a Computer Scientist, another book that focuses on Python.

I guess I could best help if I knew what your goals and intentions are. If you want to learn the basics, you can't go wrong with installing a virtual machine with some simple virtual hardware and code at the hardware level. You could even go so far as to build a computer from individual components connected in a specific circuit and hard-code the hardware itself. If you want to learn the more modern, abstract methods, I would strongly suggest Python, C#, or Java. There are many good books on each subject.

u/Wiggledan · 3 pointsr/learnprogramming

Definitely the 2nd edition. The primary difference to my knowledge is that the 2nd edition is revised to conform to ANSI standards, but other than that it's the same.

Like /u/ixAp0c said, it is an old book, so some of the things they do aren't necessarily modern practices or perfect. You should look into debuggers like GDB or Visual Studio to always run your programs through. There's even stuff like memory leaks which can affect the performance of your programs without you knowing. You can't detect these leaks easily unless you use a tool like Valgrind to specifically point them out for you.

Honestly, if you want the most comprehensive, up to date book on the subject that will involve minimal Googling or external research, it's probably C Programming: A Modern Approach, 2nd ed. It's large and versatile, whereas K&R is short and concise.

u/ideidk · 2 pointsr/learnprogramming

If you did the Princeton Algorithms course and have two years experience as a professional developer you're way too advanced for CS50 and other intro classes.

The classes I'd recommend for someone in your position are:

  • Networking (probably the most relevant for you since you're a front-end dev, some knowledge about TCP/IP and HTTP would be beneficial): Udacity has a good course on this
  • Analysis of Algorithms (teaches you some more general algorithmic techniques like dynamic programming, greedy strategies, approximation algorithms, as well as how to mathematically analyze an algorithm to determine its performance): Coursera has a good course on this
  • Computer Architecture and Assembly (teaches you how a computer actually works; not terribly relevant for a front-end dev, but computers will stop being magic after you finish it): Check out OpenSecurityTraining's Intro x86 course for the best course I've ever found on this subject

    More than the above though I'd recommend learning the following concepts and subjects even though there aren't any good MOOCs on them (to my knowledge):

  • Design patterns. There's a couple books that are highly recommended on this subject: Head First Design Patterns and the aptly named Design Patterns
  • Back-end web development. You already know how to do front-end development. Learning back-end development will probably make your job easier when you have an idea of what's going on behind the scenes. It will also allow you to move to full-stack if you ever wish.
  • Design patterns.
  • Web security. Priceless for any web developer, though granted it's more relevant to back-end engineers than front-end.
  • You should really learn design patterns.
u/itdoesntmatter13 · 3 pointsr/learnprogramming

I see that you've already taken Colt Steele's courses on Udemy. I'm guessing you can work on the front as well as the back end and work with APIs. At this point, a bootcamp is a better option imo. I'm not from the US, so I can't recommend you any. I'm assuming that you're familiar with the basics and you should definitely look into learning frameworks now. It can get overwhelming to select one amongst the plethora of available options, so pick one of the popular ones, you can't go wrong with it. ReactJS for the front end or NodeJS for the back end would be great imo (especially since you're familiar with JavaScript at this point). Udemy courses are cheap and if you follow along, you'd have multiple projects under your belt, that should definitely help you in getting a job. If time permits, you should learn auxiliary subjects, especially Algorithms and Data Structures. That would really help you in your interviews. Eventually, get that Gayle Laakmann book. So, even though you have a long road ahead of you, prioritize and focus on the parts that can get you a job in the shortest time. Maybe work on your front end skills first, get a job and work through the back end or theoretical stuff later. I'm sure you can do it if you keep at it! Good luck with everything 👍

u/ixAp0c · 2 pointsr/learnprogramming

Yes, it's possible, especially with something like Amazon where the syntax is relatively simple. If you view the HTML source for a page like this, and press CTRL + F (find/search page) and search for the price of the item ($59.87 in this case), you'll see that the price is in the HTML tag:

<span class="a-size-medium a-color-price offer-price a-text-normal">$59.87</span>

With a simple script in Python you could just pull the HTML from the web page, and parse the text for that sub-string and return the value after the substring. This script will read the HTML from the site:

!/usr/bin/env python

import urllib.request<br />

page = urllib.request.urlopen(";)
text ="utf8")


You just need to add in a few lines to make it get the value for the item. You can use string indexing and slicing to pull the value out of the HTML tag, by doing something like:

priceStartOffset = text.find('"a-size-medium a-color-price offer-price a-text-normal"&gt;$' # Find string index where price starts
priceStart = priceStartOffset + 1 # Index where price begins (numbers)
priceEnd = priceStart + 4 # Index where price ends (other ways to implement, this is simple way)
price = text[priceStart:priceEnd] # Pull price substring out of HTML by using slicing
print(price) # Display the price

Once you have the price value you can do whatever you want with it, print it to the screen, save it in a file for later use/computation, etc. Note that this is just a basic example of pulling some data from an HTML page, the logic that you implement on that data is up to you.

If you want the program to collect the price every X amount of seconds, you could put the code that gets the price in a loop (a while loop would be good in this case), with something like the 'time.sleep(seconds)' at the bottom of the loop block, so you aren't collecting thousands of the same price value every minute.

Since you have little to no experience coding (and might not really understand any of what I just said unless you're already coding), I'd recommend you read a book like Head First Programming, which goes over the basics of programming using Python 3 (but the concepts can be applied to any language, Python was simply chosen for the examples).

u/samort7 · 3 pointsr/learnprogramming

I saw someone posting Head First Java and you might want to take a look at this thread and this thread in regards to that book. Here's my opinion from those threads:

Headfirst Java was published in 2005. It's 13 years old. If you're looking to learn Java, there are plenty of excellent resources that also cover the latest features of the language:

u/aLogicalOperator · 2 pointsr/learnprogramming

First off I messed with a lot of languages before I think I really grasped the basics. I'll note that I used some Qbasic and Lua before starting my CS degree but I don't think they taught me good fundamentals because they are a little more "simple" and left me confused looking at lower level languages which is pretty much anything else.

I just started my CS degree recently and finished the first class which was in C#. I felt like this language really gave me a better grasp on the fundamentals.

More importantly than the language though I'd say get yourself a good book. For my C# class we used this book which is really good but kind of expensive. If you are interested in C++ many people recommend C++ Primer or The C++ Programming Language.

In taking my C# class I realized I thought I knew a lot about the basics of programming but actually didn't fully understand some very basic stuff, even things I had used a lot before.

u/sticksnbeans · 2 pointsr/learnprogramming

Python is an easier starting point than C. I've tried to learn Python many times, but I always find myself gravitating toward C.

C Programming Language by Kernighan and Ritchie is a very good book to pick up.

C Primer Plus by Stephen Prata is another good one for the C language. I gravitate heavily toward C. Mostly because it interests me. Also the first programming language I've ever decided to pick up.

Do not give up denizen! Programming is an exciting experience when you get things to work properly. There is so much you can do with it.

Best piece of advice is to choose what best suites your interests, and goals.

u/dmazzoni · 2 pointsr/learnprogramming

Your new home will be the Chrome Developer Tools. If you prefer Firefox, the built-in tools are also pretty good, but consider installing Firebug too. With these tools, you can debug JavaScript and even interactively run JavaScript commands, but you can also inspect HTML and CSS to find problems. If you ever find yourself randomly changing lines of code and reloading the page to see what happens, you're doing it wrong.

If you don't already know JavaScript, I'd recommend JavaScript: The Good Parts to learn JavaScript as a pure language. It's actually a pretty decent language if you stick to the good parts. A lot of complaints about web development are rooted in earlier versions of JavaScript and earlier versions of browsers that had incompatible DOM APIs - the world is much better now.

HTML itself is pretty easy. It should take you hardly any time to learn HTML by itself.

For CSS, consider CSS3: The Missing Manual. Even if you're not a graphic designer and don't want to do fancy layout, you should at least dive into CSS enough to see how it can be used for things like animation and transitions (so you know what's possible with CSS and don't try to reinvent it with HTML and JavaScript).

The last step is putting it all together - using JavaScript to modify the HTML DOM in real-time using JavaScript, and using software running on your web server in Python, PHP, Ruby, or whatever language you prefer to generate the HTML dynamically. Once you're comfortable with the other pieces, you can dive into this last step - but here's where there's more than one way to do it. Some people prefer jQuery on the front end plus PHP on the back end, others prefer Node.js so they can use JavaScript throughout, then there's Angular plus Google App Engine, and so on.

u/guifroes · 2 pointsr/learnprogramming


Looks to me that you can "feel" what good code looks like but you're not able to rationalise it enough for you to write it on your own.

Couple of suggestions:

When you see elegant code, ask yourself: why is it elegant? Is it because is simple? Easy to understand? Try to recognise the desired attributes so you can try to reproduce on your code.

Try to write really short classes/methods that have only one responsibility. For more about this, search for Single Responsibility Principle.

How familiar are you with unit testing and TDD? It should help you a lot to write better designed code.

Some other resources:

u/amphanpy · 2 pointsr/learnprogramming

I heard good things about this book. It's awfully expensive, but I'm sure you could find a free copy somewhere.

Other than that, I understand how you feel. Learning programming for the first time can be a bit rough. For now, go through a book like the C++ Primer (or a similar one) and try to understand at least the basic syntax and key aspects of programming. (object oriented programming can come a little bit later!)

I also highly suggest, actually typing out a variety of C++ code related to a concept you're interested in, that is not straight from the textbook, then compiling and running it. For example, make an array of ints, then an array of doubles. Or write a function that multiplies two argument values and returns a double, then write a function that returns void, but also multiplies two argument values and instead prints the output. Or write a program that does a combination of things like loops, calling functions, iterating over an array. It doesn't have to be anything amazing.

u/greyfade · 3 pointsr/learnprogramming

Keep working through your Python book. From what I've read, it seems to be a good book, and Python is worth being familiar with.

When you feel like you need a change of pace, watch Buckland's lectures. He doesn't dive into C right away, but instead talks about a very simplified low-level machine code. (It's simple enough, actually, that you could very easily implement a virtual machine for it in Python.) It'll help you build an understanding of how programs actually run, so that when you pick up a book on C, things will make more sense.

Then, when you feel confident in Python, go grab a book on C. I don't have any specific recommendations (there are a ton of good books) but it's nice to have a copy of K&amp;R C on hand. Then you'll want a book on data structures. Maybe Introduction to Algorithms.

u/Shadowhawk109 · 6 pointsr/learnprogramming

MVC is just a paradigm. Implementations differ from language to language, and some languages have better support than others, but yeah, just a paradigm.

Look into Design Patterns by the (in)famous "Gang of Four" for more information about this.

I will say this -- most experience I have with C# backends leads to great usage of databinding between model and view regardless of application platform (WPF, Windows Forms, even some ASP.NET). And I'm pretty impressed with the support of other design structures that C# and Visual Studio offer with the help of NuGet (looking at you, Angular).

u/Bonta-Kun · 15 pointsr/learnprogramming

I've found Cracking the coding interview to be an excellent resource. That book together with online sources helped me get several internship offers. The book won't spoon feed you from the ground up - but will cover all the topics necessary. The interview questions are all about PRACTICE! Spend a lot of time thinking about how to solve programming questions, the complexity of your solution, and ways to improve your solution.

After a while, you should reach a point where you start recognizing patterns when you see a new question. There are often existing data structures (that you must know backwards - like hash tables) that you can use to solve a given problem - try and think of which one fits the question nicely.

Finally, read this. Good luck!

u/llFLAWLESSll · 3 pointsr/learnprogramming

Since you know Java I would suggest that you a read one of the best programming books ever written: [K&amp;R The C Programming language] (, this book was written by the people who made the C language and it's one of the best books ever written. It is a must read for every C programmer. [Computer Systems: A Programmer's Perspective (3rd Edition)] ( is a great book to learn about computer systems. But I would recommend [Operating Systems Design and Implementation (3rd Edition)] ( because it has some minix source code which will go really well with learning C.

Best of luck buddy :)

u/AlSweigart · 1 pointr/learnprogramming

Find out what language the class is using. If it is Java, then I've heard that Thinking in Java is a good book (the 3rd edition is free while the 4th is not).

Here are some books you should read, the sooner the better:

Code: The Hidden Language of Hardware and Software - This is a great book that is technical while being a fairly light read. It answers the question "how do computers physically work?" with just enough theory to understand, and it doesn't have, like, metaphors of pictures of trains carrying 1s and 0s around.

Don't Make Me Think and User Interface Design for Programmers which are also light-but-still-technical books on user interface design, which gives a good idea of how to create software that people actually use.

At some point after you've done some coding, read these books:

Code Complete - A great tome of the non-programming aspects of being a good software engineer.

Pragmatic Programmer is a technical book, and probably a good one to read towards the end of your first year maybe.

Also note: You don't need to know a lot of math to program. High school level algebra and basic arithmetic is fine for the most part.

u/Wolfspaw · 3 pointsr/learnprogramming

There are some good books to help you in your quest, they discusses all programming techniques needed in competitions: greedy algorithms, dynamic programming, data structures... A lot of overlap
between them :

Competitive Programming 2 : Great book, a lot of
information packed

Art of Programming Contest : FREE book available from ACM site

Programming Challenges : From a famous
competition Professor (Skiena)

The Hitchker Guide to Programming Contests : Another FREE book,
Great Ideas

The Algorithm Design Manual : Another book from
skiena, talks about the practical applications of famous techniques and
algorithms used in competitions

Introduction to algorithms : THE book about
algorithms... In-depth explanations

Google code Jam contest analysis : Google Code Jam is a great
competition, with a lot of hard problems. And all of them have a
solution and analysis !

u/UpAndDownArrows · 3 pointsr/learnprogramming

First time see that site, but I would recommend reading:

u/zzyzzyxx · 2 pointsr/learnprogramming

&gt; I'm really only showing them the deep end

Fair enough.

&gt; const correctness has less functional impact on what a program does than functions/arrays/pointers/OOP/many-other-concepts

True, it doesn't affect the behavior of the code. But code that works is not inherently good code. It's hard to write good code in C++ and I see a lot of bad C++ come through r/learnprogramming so I am of the opinion that best practices should be taught early. I can understand your argument with opportunity cost though.

Perhaps it's sufficient to say at the outset "if you don't expect something to change, mark it const; I'll explain further in the future". Then in your lectures you can mention it in passing, e.g. "This function should not modify this parameter so I am making it const". It's easier to remove a too-restrictive const than it is to insert a necessary one later. You can expose them to consistently good const usage before you explain in detail.

&gt; I may ask for your feedback on that lecture specifically when I do it, if you're willing to participate.

Absolutely. Just let me know when.

&gt; Movie editing is the problem

Oh, sorry; I misunderstood. Lightworks seems to be the best free editor comparable to Premiere.

&gt; Any suggestions for good resources

In my opinion, C++ is always best learned from a book. The two that I would recommend right now are C++ Primer 5th ed and The C++ Standard Library 2nd ed. Though you will be able to skip around to the C++11 parts, both would also be good for your students.

u/quad64bit · 2 pointsr/learnprogramming

If you're working with a list that is larger than memory (billions of entries) and it is unordered, then this is quite a task. You can sort elements with something like a merge sort...

However, if you are working with in-memory lists, the best performance you can hope for is to sort the list initially, and then perform the binary search you described.

Bubsyouruncle described a binary search tree. This is a nifty data structure because simply inserting elements into the tree partially orders them. You can then efficiently look up elements without having to presort all the time. It allows for tolerable insertions with excellent lookup times.

If you are using a language like Java, these data structures have all been written for you; you can simply make use of them. If you would like to implement this kind of thing from scratch as a learning exercise, take a look at the wiki for starters.

An excellent (albeit advanced) data structures book can be found here:
Intro to Algorithms

The book contains a bunch of data structures and all the core algorithms you use for just about everything - trees, maps, traversals, in-place structures, etc...

u/jesyspa · 1 pointr/learnprogramming

I should probably clarify what bothers me. I find that programming is a creative activity, and what while attention to detail is important, it's just as important to have a large-scale overview of what you are doing. You're going to have practical problems if you can't write an if statement correctly, but making the goal of the exercise to write an if statement doesn't sound much better to me.

In this regard, LPTHW reminds me of secondary school maths classes: you're shown how certain basic problems are solved, and then told to use that formula to solve more problems of the same style, perhaps with some variation. Yes, there will be people who can put these blocks together and see the beautiful structure that they add up to, and yes, learning how to plug numbers into an equation is easier than solving problems yourself. Still, it doesn't work well in mathematics, and I am sceptical of it in programming.

I by far prefer books like Invent With Python, where it is immediately clear that the things you learn aren't just features in isolation, and where the whole-program structure is emphasised. An even better book (though not about Python) is The C++ Programming Language; reading that truly gives the feeling of a coherent system. (Not to imply that it's a good first introduction to programming in general, but neither was it meant as one.)

TL;DR: Do what works, but if you're not making a project of your own, I'd consider starting on one.

u/TonySu · 1 pointr/learnprogramming

I'm a Masters of Statistics student with quite a bit of interest in programming. I'm currently working through Discovering modern C++ which I find to be a nice concise text about modern features of C++. Many other C++ texts don't tend to make good use of modern C++ functionailities and end up with codes and styles that look like C more than C++.

In general I find people with Math/Stats write terrible code. So I really would recommend The Pragmatic Programmer and Clean Code for good programming practices (I prefer the latter to the former but both are good). Us maths students are too used to having abstractions in our head that we don't make clear in our code. We quickly synthesise complicated solutions to problems and code it up without making the logic transparent. Coding is a lot more fun when you don't need to sit around for a hour working out why the code you wrote a month ago works.

I'd recommend learning algorithms (texts already suggests elsewhere) using high level languages like R and Python. It's significantly easier to code up simple structures and algorithms without having to simultaneously grapple with a complicated language and its features. You are unlikely to ever code up your own efficient data structure or algorithm, the point is to understand the benefits of each and use someone elses implementation when you need to.

Finally always code with some form of static code analysis. For me this means using Sublime Text along with a SublimeLinter plug-in, there's a different linter for most languages. This will keep your code conforming with good standards and force you out of bad habits.

u/IRLeif · 6 pointsr/learnprogramming

Looks like most of your knowledge and experience so far is with imperative/object-oriented programming. You might want to have a look at functional programming, just to get some perspective. Scala, Erlang or Haskell could be some good choices here, or even Ruby (if you make use of blocks and don't use mutable data). Actually, Ruby is pretty cool and very versatile and practical, that could be a good language choice as well, and you would also be able to make use of your prior knowledge with OO programming.

One other thing that you could do with this time is to read some books! There are some wonderful "generic" titles that every programmer should read, in my opinion. Have a look at The Pragmatic Programmer, Clean Code and Code Complete, for starters. These might get you really inspired and pumped up for the undergrad college and computer science classes, as well as give you some good tips on new things to learn.

u/pornlord · 2 pointsr/learnprogramming

It seems to me you have set the bar too high. Searching and sorting algorithms alone are one semester course and are programming language independent. You are not tied to Java to learn them, though coding them up in Java will help you come to grips with the language.

If you really want to learn the language, then try to implement the first part of your goal that is stacks, queues, linked lists and binary trees. Do not let the jargon " abstraction as applied to elementary ..." come in between. Ask your faculty in helping to write efficient and robust code, that is make your stacks, queues, lists and trees take any sort of data that is use generics they are a big thing in Java. This will help you understand how to make your code be able to serve any type of data.

After you have done the coding of these data structures compare them with the libraries that Java provides for list, stack, queues. This comparison will give you insight as to how to write better code in Java.

Also try to learn a few patterns while coding these things up. For starts you can go to sourcemaking or look up at the book Head First design patterns. You may get lost here or overwhelmed, so do ask your faculty for guidance here as to what you should cherry pick to get the best footing.

Congratulations, and all the best for your job!

u/reddilada · 1 pointr/learnprogramming

That's close. sizeof() only returns the value of what you give it. In this case value1 is a char pointer so it would return probably 4 (32 bit system). What you want is the length of what value1 is pointing at. strlen() will give you that. The next catch is when you malloc you have to account for the null value that always terminates a string. So, "hello" has a string length of five, but it is actually six bytes long to accommodate the null that occurs after the o.

You would do all of this in the newStockItem function for each of the string types in your structure.

get the length of value
allocate length + 1 bytes, assign that to s-&gt;whatever.
copy value to s-&gt;whatever.

If you haven't gone through the K&amp;R book The C Programming Language I would encourage you to do so. It's a short book, but covers everything you need to know. C is fairly simple on the surface, but some of it isn't obvious without going through some sort of guide. K&amp;R is the best you can get. If you get through the book, you'll know everything there is to know about C :)

I got my first job as a C programmer forty years ago having only read this book. At the time I had never compiled a single C program!

u/sleepybychoice · 1 pointr/learnprogramming

Note: I haven't actually read either of these, but they do have good reviews on Amazon. :-)

u/Waitwhatwtf · 2 pointsr/learnprogramming

A fair amount of iOS devs I know say that starting with a background in C can definitely help you in the long run, so I'd highly recommend K&amp;R for that.

After you're done with that, you're definitely going to want to learn the Cocoa API along side Objective-C, and Hillegass does that quite nicely. Once you're familiar with that, this book will help you familiarize yourself with the language further.

Bonus round dice roll:

If you want to make a game, I recommend learning some opengl.

u/interactionjackson · 1 pointr/learnprogramming

I would never say never. They have their uses but there is definitely some best practices to adhere to if you choose to use them. Clean code by Robert Martin is a great book to read and details best practices.

u/Durshka · 1 pointr/learnprogramming

Ah, thanks :) Sorry I can't be more help! Maybe go looking for some books? A friend of mine lent me some books to get me started but they were too far above the basics for me to dig into. You might have better luck checking out Amazon or going to a bookstore and flicking through any of the C# books there to see if they'd interest you. The ones she gave me were: The Pragmatic Programmer, C# for Java Developers and CLR via C#, she gave me the 2nd edition, but the 3rd one is available. All I know about them at the moment is that they're further along than I am :)

u/salihzain35 · 5 pointsr/learnprogramming

I’m taking Data Structures and Algorithms right now. It’s definitely not an easy class so it’s very ok to struggle. I’m not sure which language are you guys using, but if you’re using Java, then this is an amazing book that starts from the basics!;amp;qid=1536420166&amp;amp;sr=8-4&amp;amp;pi=AC_SX236_SY340_QL65&amp;amp;keywords=algorithms&amp;amp;dpPl=1&amp;amp;dpID=41%2BpJNrGujL&amp;amp;ref=plSrch

On the other hand, you have to build things by your hand in order to understand them. Don’t worry about how quick you get the concepts, it’s ok to meditate on them. After all, what took scientists years to build is not supposed to be understood in an hour. Take your time and good luck!

u/eatstraw · 5 pointsr/learnprogramming

Here's a really good book by someone who used to conduct coding interviews at Microsoft, Amazon, etc.

Cracking the Coding Interview

Still, it's not likely that you'll see the same exact questions on an actual interview. Just practice a lot and get comfortable with solving problems. That will help you when it's time to code on-the-fly at an interview. Also, it's more important to talk through the solutions. Coming up with an innovative, elegant, or efficient solution with pseudocode is more important than getting the syntax exactly right in a particular programming language.

u/realfizzbuzzed · 5 pointsr/learnprogramming

For language specific stuff like c++ I'd suggest: as a pretty good quick review. Going through c++ primer (or whatever book you learned C++ from) and just touching on all the topics that you don't remember can help a lot.

What helped me with design patterns is head first design patterns. Even though that book seems very 'intro' it has helped me pass all the design pattern question I've ever gotten. I think just visitor, singleton and MVC are the most popular interview design patterns. The more canonical 'gang of four' book would be: this.

For just practice tech interview problems that you'll see on silicon valley, big4 tech interviews, the most popular site is probably leetcode (hackerrank, or top coder or even codewars are pretty good sources too). The most popular book (as mentioned many times) is Cracking the coding interview.

Just grinding out problems on leetcode, you'll probably learn enough to pass most tech interviews after about 100-200 questions (if you've never done this before, less if you have).

Before/during your leetcode practice I've written a series of tech interview tips to help you check on your fundamentals (you can check it out at I try to go over the questions I see people failing most often. I'm also trying to help readers so would love to help you if you run into problems.

I also think you should ask the recruiter the style of interview you'll be having. If you are on the whiteboard then you should practice on it before hand (whiteboard interview tips here.

u/Cgseif · 3 pointsr/learnprogramming

I'm like you - also in high school and casually building my programming skills. I'm not really sure what you are looking for, or what your previous experience is. Have you looked into design patterns, object-oriented programming principles, etc? Do you make mini projects for yourself to complete? I recommend definitely looking into OOP (if you haven't already), design patterns, refactoring to improve your code, etc. Have you tried contributing to any open-source projects? Those might be useful for gaining more experience.

Code Complete is a must read (IMO) for any programmer.

Head First Object-Oriented Analysis &amp; Design is one I'm a fan of as well. Taught me how to look at the bigger picture when coding.

Hope this helped somewhat!

u/SpoobyPls · 1 pointr/learnprogramming

There are a few books I recommend. I think a couple of things are very important to wrap your head around, but before all that comes the basics. For instance, knowing your primitive types, methods, loops, and even OOP which would include things like; classes, structs, inheritance, polymorphism, etc,.

Then move onto some very good readings;

  1. Clean Code - This book is going to go through a lot of concepts and keeping your code maintainable and is a very short read.
  2. The Pragmatic Programmer - This one will go through, what I believe, you're looking for. Helps you get into the mindset of a 'pragmatic programmer.'
  3. Introduction to Algorithms - This I wouldn't start until you're fairly comfortable with programming in the language you are familiar with. By this point you should definitely have the basics down. In fact, I might argue do this one after you've read the other two.
  4. Lastly, I'd recommend doing Project Euler which is really going to put your skills to the test. It is very mathematical but if you're up for the challenge this will push you far.
u/SeanNoxious · 3 pointsr/learnprogramming

I have done a lot of interview prep in the past but would always be interested in keeping my skills sharp. I highly recommend this book it's really the most comprehensive text you can get for any generic coding interview. I am interested in learning but if there is anything I can do to contribute, I would be happy too as well.

u/Mydrax · 118 pointsr/learnprogramming

Well, this is usually because C++ is not really a beginner friendly language. You need to understand the architecture/fundamentals of a computer system at times to understand certain concepts and are often difficult to understand ex: pointers, dynamic memory allocation etc. and with C++ you never finish learning!

Yes, you are very correct about understanding basics before doing actual game-based programming, C++ Primer is pretty old but it's definitely a golden book alongside it though for someone like you I will suggest some of the books I read a couple years back and some that I believe are better for beginners:

Accelerated C++: Practical Programming by Example

Programming: Principles and Practice Using C++

The C++ Programming Language, 4th Edition- Very big book, read this after you've read the rest.

And a book that I've heard is pretty good for game development with c++:

u/wpnx · 1 pointr/learnprogramming

Books are great to learn the foundations, but the real ah-ha moments come from implementing end to end projects. Pick something small (tic-tac-toe for example) and move your way up. You should take a look at the google android tutorial after you think you have a basic grasp of the language

You will probably struggle a lot, but thats how the best learning happens. Stack overflow will be your friend for most questions.

Intellij is the best IDE out there for java: here

As for books, I've heard good things about the head first series.

u/ironmaiden947 · 7 pointsr/learnprogramming

The C Programming Language by K&amp;R is probably the first book people recommend.

Learn C The Hard Way is more hands-on, but if you already know other programming languages youll be fine.

I dont know about any interactive courses, but HackerRank has lots of challanges you can solve in a multitude of languages (including C) which is pretty close to CodeAcademy. Keep in mind that it gets hard pretty quick, so it is better to be somewhat comfortable with your chosen language before doing them.

u/deiphiz · 7 pointsr/learnprogramming

Okay, I'm gonna plug this in here. I hope this doesn't get buried because when I saw someone asking about low level stuff here, I couldn't help but make this recommendation.

For anyone that wants to learn more about low level computer stuff such as assembly code should read the book Code: The Hidden Language of Computer Hardware and Software by Charles Petzold. I've been reading it recently and I'm really glad I picked it up. It really delves into how a computer really works, like how languages relate to the circuits on a board.

So yeah, /u/DEVi4TION, I recommend picking this up if you wanna know about more stuff like this. Then maybe try your hand at actual 6502 programming later :P

u/wesatloldotcat · 2 pointsr/learnprogramming and

LCTHW is more contemporary, and written by an author who may or may not be banned in this sub, it has fairly strict pedagogy, but may be more approachable for you. K&amp;R C is the definitive book on C, though it's old and slightly dry at points, I don't know your syllabus, but I think K&amp;R C would supplement well.

I've never used Visual Studio, but I've heard that Microsoft makes great development tools. These videos may help

Also, as general advice, consider starting with something other than C. It's fairly low level compared with other modern languages, and tends to be used to low level systems programming (consumer electronics or operating systems), or as a foundational knowledge to be learned but not used daily, similar English and Latin (I'm sure this analogy will piss off someone somewhere).

I'm only guessing at your goals as a biologist, but a less computational efficient but scientifically applicable language like Python or R may be a better fit.

u/YourTechnician · 1 pointr/learnprogramming

ok so at school we worked with Big Java . Good book for beginners but it doesn't seem as comprehensive. Thinking in Java is the best book in my opinion, it is covers an insane amount of topics, but it is more of a challenge in case you have a short attention span (it tends to be more serious than the others, rendering it more boring in return).
Now in case you want something more playful Head First Java is a fun one, it uses pictures , and jokes and uses day to day examples in order to make things stick better to your brain. In case you find that kind of stuff better, than it is recommended, but it does cover less than both of the predecessors.

For later inquires, you can check out the books on this list

u/MissMaster · 1 pointr/learnprogramming

I would focus more on deciding what you want to make. When you can make something that works, you're a programmer. When your code isn't brittle, is well commented/documented, is "clean" and other devs can understand and work with it, you're a good programmer.

So pick something you want to create and make it: a website, a simple program, a game, etc.

How to go about it? Once you have that thing you want to make, break it down into bite size tasks and start tackling them one at a time. First, you'll need to figure out what language and libraries you need (or want) to use. Then set up your dev environment and get a "Hello World" example to work. Then just start building piece by piece. Once it works, make it work better (i.e. refactor it).

I use a bunch of resources to be a better programmer:

  • dev blogs (a google search for "best &lt;insert your field here&gt; blogs" should give you some good ones

  • books for the basics. I can particularly recommend Code Complete 2, The Pragmatic Programmer, Head First Design Patterns, Design Patterns: Elements of Reusable OO Software and Algorithms in a Nutshell

  • Tutorials. I love a good tutorial. The trick is to find one written by a professional (usually on a blog you trust or from a tutorials site that vets the content, like tutsplus). Unfortunately, any asshat can throw up shitty code and call it a tutorial, so be careful googling and look at the comments first to look for people calling out issues. As you get more experience, you'll be able to spot 'code smell'.

  • pair programming. I hate pair programming. I instantly lose my ability to type or form coherent thoughts when someone is lurking over my shoulder. I am constantly terrified that someone will think I'm stupid. But it works.

  • fellow devs. Nothing really replaces direct communication with another dev. Find someone or a community online or at work who you are comfortable with. Someone you can go to when you're stuck or don't get something. The difference between needing babysitting and needing help is having specific questions. Instead of saying "I don't understand x", approach them with a more specific question like "I'm trying to get comfortable with closures so I set up a simple counter, but instead of counting to 10, I get 10 printed 10 times, can you help me spot where my error is?"

    I hope that helps.
u/SuperDuckQ · 1 pointr/learnprogramming

There are two books I would recommend to you as I think they address what you are looking to improve upon. First I would recommend

Clean Code: A Handbook of Agile Software Craftmanship

followed up by Code Complete

Both deal with project management, etc., but have fantastic sections on code style and presentation. I really liked "Clean Code" and would recommend it to anyone. What you are describing in your last paragraph is one of its main goals. Both books present principles that are language agnostic (though usually have examples in Java/C formatted languages).

u/chekt · 21 pointsr/learnprogramming

As a beginner, the resources you use to learn are much more important than the programming language you end up learning with them. C++ may be more complex than C#, but they're both incredibly complex for a beginner, and so your effectiveness starting out relies an incredible amount on which books you choose to go through. When I was learning C++, I really enjoyed the book Accelerated C++ by Koeing and Moo. It eschews the "learn c, then c++" attitude some other books have, and believes that C++ is significantly different enough from C to warrant a different approach. And you learn C++ one piece at a time, so it's never overwhelming. I heartily recommend it if you decide to learn C++.

I don't own any C# books for beginners, so you'll have to ask someone else for a recommendation :P.

Just a quick note: programming is incredibly difficult when you're just starting out, but it's 10x as rewarding, and is one of the most fun skills you can pick up. Good luck on your journey!

u/Stormtalons · 5 pointsr/learnprogramming

I've got some tips for ya!

  • If you find learning about things like local and global scope fascinating and devour info about coding, then I can confidently say congratulations on finding your calling! There are many, many programmers who never do any reading, find it boring, and, consequently, have limited perspective and suck ass.

  • In programming, no matter whether you're a novice or a veteran, the 'big picture' is like that hot girl in high school that you somehow talked into dating you off and on until you both graduated, and then she never spoke to you again. On large projects like games, it's highly unlikely that anybody truly knows the entire scope and can tell you how every piece works together. Even on smaller, personal projects that only you yourself worked on, you will probably have to read your whole codebase to remember what the hell you were thinking if you revisit it in 6 months. So, don't sweat it too much if you don't get the big picture, or if it takes you a long time to grasp, just relax and remember that all programmers spend the vast majority of their time simply understanding code.

  • My personal opinion on using C++ as opposed to Java or .NET - imagine an application is a physical building. If you use C++, you have to take the time to fabricate every single brick you're gonna use, forge your own plumbing pipes, and construct everything from scratch. Java or .NET will deliver all of your bricks, steel, drywall, shingles, cabinets, and appliances in regular shipments, so you can focus on the blueprints and management. In the time it takes you to build a house in C++, you could have built a whole apartment complex in Java/.NET and rented out most of the units already. Having said that, if you want to build a fortress in the heart of a mountain where the only access is a tunnel hidden behind a waterfall with a door that's unlocked by DNA signature, you should probably use C++.

  • When will it fall into place? It's impossible to tell. It's different for everybody and depends highly on what you are doing and what your goals are. For me, it took about 6 months to get a handle on the basics, and 2-3 years to become confident discussing higher level design principles intelligently, and to start nodding my head in agreement reading programming blogs. I knew that things had finally clicked when I realized I was no longer shackled to the language I learned first, and that using new platforms was merely an example/API skim away.

  • I highly recommend reading through pretty much all of the Coding Horror posts, as well as Code Complete 2. Find something to build that interests you and that you don't know off-hand how to accomplish, and then learn the pieces you're missing to get it done. Google every topic, acronym, or piece of terminology that you're not familiar with, rinse and repeat. If you are truly a good programmer you will never think of yourself as a good programmer, but you will wake up one day and realize that you have the ability to complete most any task thrown your way; and if you don't, you'll know how to learn what you need to get it done.
u/SoBoredAtWork · 1 pointr/learnprogramming

If you're looking for best practices, check out "The Right Way" series of sites:

For a JS best practices book, check out Javascript: The Good Parts

For interactive online tutorials, Code Acadamy is pretty cool and there are others like it.

And here's an advanced guide to HTML &amp; CSS to learn more in-depth best practices.

Tip: stay away from W3Schools! There's a lot of bad info on the site.

edit(s): I didn't grammar correctly.

u/jalabi99 · 13 pointsr/learnprogramming

For one thing, although you may know a few languages (you mentioned Java, Visual Basic, and SQL, which isn't a language per se but you know what I mean), you may not know how to work with remote teams. You may not know how to use code versioning systems like git or SVN. You may not know how to use continuous integration software like Jenkins. You may not know how to use these and more, simply because you were never exposed to them in the course of your studies. And that's perfectly fine. You can't know everything. The problem though is that so many employers expect you to know all these things, even though you may have never even heard of them before this post.

That is exactly why /u/ResidentBiscuit said "the journey has only just begun." It's an exciting time!

I agree with what was said here:

&gt; The Pragmatic Programmer contains 46 tips for software professionals that are simply indispensable. As the name implies, the book avoids falling into any kind of religious wars with its tips, it's simply about pragmatism.

&gt; If you were to read only one book on this list, this is the one to read. It never goes terribly deep into anything, but it has a great breadth, covering the basics that will take a recent college-grad and transform him or her into someone employable, who can be a useful member of a team.

u/Xeronate · 9 pointsr/learnprogramming

This video is a Google interview example so of course the problem is a bit contrived, but I think it is a decent illustration of the process he is referring to. The guy writes the code out in C++, but you could just as easily write in pseudocode.

Solving the problem by hand and writing a sketch of the algorithm builds intuition and makes the actual code much easier to write. People knock interview prep as being nothing like the job, but I find that it can do a lot to boost general problem solving. CTCI and leetcode are good resources. If you are brand new to programming Codingbat might be useful, but it is really just for the basics.

u/Idoiocracy · 2 pointsr/learnprogramming

I also recommend the C Programming: A Modern Approach by K.N. King. It's considerably longer than Kernighan &amp; Ritchie's book, but does provide more explanation which can be helpful for a beginner. A Modern Approach is considered one of the best starting C books among those who read it. Your local library might have a copy of both if you want to read them cheaply.

If you wish to start with Python instead, a good book is Python Programming: An Introduction to Computer Science by John Zelle.

u/EricTboneJackson · 3 pointsr/learnprogramming

I know this is somewhat contrary to your request, but I would recommend reading The C Programming Language, by Kernighan and Ritchie. Ritchie invented the language, and Kernighan's writing is the best in the business. It's short, crystal clear, full of examples, and an absolutely joy to read.