Best computer programming books according to redditors
We found 8,316 Reddit comments discussing the best computer programming books. We ranked the 1,691 resulting products by number of redditors who mentioned them. Here are the top 20.
We found 8,316 Reddit comments discussing the best computer programming books. We ranked the 1,691 resulting products by number of redditors who mentioned them. Here are the top 20.
I always recommend this book called 'Clean Code'
It details a collection of techniques to keep your code readable and maintainable.
In general use good variable and method names and use more, shorter methods where appropriate
Start to focus on your problem solving skills and work on improving them. There are quite a lot of good resources out there on things you can do to improve this skill, mostly the revolve around breaking up the problem into smaller parts and constant practice. You might find some of these helpful and there are many other resources out there:
Then once you have given a few of these a read start practicing on site like the following:
You don't have to sign up to all of these, just one will do but they all vary in what languages and problem areas the focus on so find one that has the stuff you want to work with. Then keep practicing and learning using what you learnt from the guides above to help you.
---
That said there is also nothing wrong with looking at how others have solved a particular problem - especially if you have had a go at it first. Compare and contrast your solutions and see what benefits there are with each approach - this is how you improve. Over time you do begin to take on these improvements and quite often you see other ways to solve a problem that you would not have through of - they key is to try to understand what is going on and try to give out why someone solve it in this way.
Here's my list of the classics:
General Computing
Computer Science
Software Development
Case Studies
Employment
Language-Specific
C
Python
C#
C++
Java
Linux Shell Scripts
Web Development
Ruby and Rails
Assembly
Refactoring: Improving the design of existing code
Design Patterns
Working Effectively with legacy code
Clean Code
How to be a programmer
Then there are language specific books which are really good. I think if you read the above, slowly over time, you'll be in a great place. Don't think you need to read them all before you start.
Isn't this argument kind of a strawman?
Who says that self-documenting code means absolutely no comments? Even the biggest champion of self-documenting code, Uncle Bob, devotes an entire chapter in Clean Code to effective commenting practices.
The idea of "self-documenting code" is that comments are at best a crutch to explain a bad design, and a worst, lies. Especially as the code changes and then you have to update those comments, which becomes extremely tedious if the comments are at too low a level of detail.
Thus, while code should be self-documenting, comments should be sparse and have demonstrable value when present. This is in line with the Agile philosophy that working code is more important than documentation, but that doesn't mean that documentation isn't important. Whatever documents are created should prove themselves necessary instead of busy work that no one will refer to later.
Uncle Bob presents categories of "good comments":
Some examples of "bad comments":
Android team lead here, I've been working with Android commercially since 2009 (before Android 2.0 was released) and have worked at, or done work for, some big companies (Mozilla, Intel, Google, HTC...). I was in a very similar situation to you in that I was a web development and was bored, I'd been playing with Android in my spare time; I got my first break by volunteering to do an android app at the company I worked for, and went from permanent employee to contractor fairly quickly after that and have been doing it ever since.
First thing to say is that if you can get your currently company to pay you to learn android and stay with them, that's a win win for both parties (you get to learn something new without a drop in salary and don't have to interview and they don't lose a good member of staff).
In terms of moving company, I don't know where you are based, but here in the UK I often see junior Android contract roles coming up for £200-300 a day. Failing that it's just a case of applying for lots of poisitions and really knowing your stuff.
What I would look for in a junior is to have read, understood and put in to practice Clean Code (https://www.amazon.co.uk/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882) and Design Patterns (https://www.amazon.co.uk/Head-First-Design-Patterns-Freeman/dp/0596007124). I would expect you to have a good understanding of basic Java and OOP; a working understanding of MVP or MVVM (https://news.realm.io/news/eric-maxwell-mvc-mvp-and-mvvm-on-android/, https://www.linkedin.com/pulse/understanding-difference-between-mvc-mvp-mvvm-design-rishabh-software); understand threading; know about all the major parts of Android (Services, Broadcast receviers, Activities, Fragments etc); know how to write a custom view; be able to efficiently design a layout in XML and correctly apply styles and themes; understand the support libraries - what they contain, why they exist and what they are used for (and also when you don't need them); understand the difference between unit testing and integration testing and know what makes for a good test; the Gradle build system is a really nice way of defining your project build - knowing the fundamentals is essential.
A few of the main libraries I'd expect you to know and have used would be OkHttp (https://github.com/square/okhttp), Retrofit (https://github.com/square/retrofit), Butterknife (https://jakewharton.github.io/butterknife/), Picasso (https://square.github.io/picasso/) or some other image loading library, GSON (https://github.com/google/gson) or Moshi (https://github.com/square/moshi) or some other json parsing library
If you want to level up then there are loads of advanced topics surrounding Android. Any of these following topics will take a while to learn, but will be worth it and will look good in interviews and on you CV:
There's so much more - this is a large topic and it's easy to feel overwhelmed (I know I did & do) but the sheer amount of stuff to learn, but take it slowly and it'll come. The best way that I found to learn all of this stuff is to have a personal project which I was working on (I started doing an app which teaches you how to play guitar - never released it but learned so much). Get the fundamentals down and them start looking at some of the more advanced things. A good test app would be to write a Reddit client (they have open APIs: https://www.reddit.com/dev/api/) - this will get you up to speed on networking, background services (to poll the API to see if you have any messages) etc
Let me know if this helped or if you want to chat about stuff. Happy to help.
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++: https://www.amazon.com/Mastering-Game-Development-professional-realistic/dp/1788629221
You need to build up a foundational set of programming skills. Frameworks and libraries are important to know, but not as important as knowing how to program. The difference between a program/website/webapp that works, and a program/website/webapp that works AND has sensible code, is significant to a company. I've seen the simplest of features take weeks to implement in very poorly written code bases. This is valuable and expensive time that could have been spent building other features.
Companies are sensitive to this because very few companies are immune to the effects of poorly written and maintained code bases, so they are going to ask you code design questions and even have you do live programming challenges to see how think about the problem, and whether the design of a solution is important to you, or whether you're content to just shit out any old solution that works and move on.
To start, with, I would familiarize yourself with the basic mechanics of the language by reading the You Don't Know JS series: https://github.com/getify/You-Dont-Know-JS/tree/1st-ed
Next, I would read Clean Code by Robert Martin. It's based in Java, but the general principles are the same.
Next, I would read Refractoring: Improving the Design of Existing Code (2nd edition - which is JavaScript based). You can read the Java-based 1st edition for free.
Finally, I would read A Mostly Adequate Guide to Functional Programming.
Yes, it's a lot of reading, but these books will help you think about your code design choices, and in combination with practice, will help you write better code. But of course there is no substitute for practice. The more you write code, the better you'll be at it. The resources I linked to are just guides, not magic bullets.
In terms of other things that are necessary to learn, you'll need to learn how to use git (not to be confused with GitHub). Git is basically the industry standard version control system. You don't have to be an expert at it, but you do need to know the basics of it.
You're also going to want to get familiar with the basics of node and npm, because even doing front-end work, you'll be relying on 3rd party packages, and running builds, all of which are managed through node and npm (or yarn).
Never liked that book tbh. If it works for you that's fine. Buit for me its tone is way too strict, condescending and most of the time it never explains why some things have to be done the way they are. It's as if the author forces his coding style on you and doesn't bother to give context.
I enjoyed "Automate the Boring Stuff with Python" much, much more.
In my opinion; every book in this bundle is a bag of shit.
Here's a list of reputable books, again in my opinion (All links are Non-Affiliate Links):
Web Hacking:
The Web Hackers Handbook (Link)
Infrastructure:
Network Security Assessment (Link)
Please Note: The examples in the book are dated (even though it's been updated to v3), but this book is the best for learning Infrastructure Testing Methodology.
General:
Hacking: The Art of Exploitation (Link)
Grey Hat Hacking (Link)
Linux:
Hacking Exposed: Linux (I don't have a link to a specific book as there are many editions / revisions for this book. Please read the reviews for the edition you want to purchase)
Metasploit:
I recommend the online course "Metaspliot Unleashed" (Link) as opposed to buying the book (Link).
Nmap:
The man pages. The book (Link) is a great reference and looks great on the bookshelf. The reality is, using Nmap is like baking a cake. There are too many variables involved in running the perfect portscan, every environment is different and as such will require tweaking to run efficiently.
Malware Analysis:
Practical Malware Analysis (Link)
The book is old, but the methodology is rock solid.
Programming / Scripting:
Python: Automate the Boring Stuff (Link)
Hope that helps.
The book Think Like a Programmer is a good match.
In the art of computer programming there are problems with a rating of 50 which are unsolved research problems.
In the first chapter they used to give Fermat's Last Theorem as a score of 50 but since it has already has a proof it is now at 45 .
https://www.amazon.com/Computer-Programming-Volumes-1-4A-Boxed/dp/0321751043/ref=sr_1_1?ie=UTF8&qid=1484672727&sr=8-1&keywords=the+art+of+computer+programming
Clean Code
I would highly recommend the Effective C++ books to anyone who is learning C++. It should be mandatory reading once you grasp the basics of C++. These books are easy to read, and the "holy shit, this could have bit me in the ass hard" factor is high.
I read an interview a long time ago where one of the K&R guys said something to the effect of "Yeah, we got some of the operator precedence rules wrong. We noticed it after awhile but we didn't change it because by that time there were hundreds of kilobytes of code written in C and it didn't seem fair to change it."
I don't remember where I read that; it might have been in this book. Incidentally the fish on the cover is a coelacanth, pronounced "C-le-kanth" and it remained undiscovered until the 20th century, making it a "Deep C secret". I love the double pun and the book was quite good.
Outliers: The Story of Success - by Malcolm Gladwell
The Pragmatic Programmer - By Andrew hunt
Cracking the coding interview - Gayle Laakmann McDowell
Some book recommendations:
Others that are great and related but not as "necessary" as the above three:
Unrelated to "better code" but still great:
A good metric is by how expensive the object you're passing around is to make a copy of. In the case where you're passing by value, you're probably returning by value as well so two deep copies there. An alternative is references which are syntactically similar to pass by value but retain the memory niceties of pointers which don't require a full copy but rather just the passing of a memory address.
Typically my rule of thumb is bigger than a pointer use a const reference unless I need a fiddle with the bits in the object I'm passing then I'll go with a pointer. Given enough practice and seeing enough code you sort of get a feel for when it's best to use what, but you kind of need to understand the tradeoffs between how you throw around data.
Passing references everywhere is bad though because it makes it less obvious to person reading/using your code that the object you're passing in could potentially be different object than the one you passed in. If your function takes a pointer it tells the reader that you probably intend to do something with the object's data in the function to change it. Which comes to the second point of using 'const' everywhere which not only informs the reader that the object will not be changed but also binds your function to a contract to not be able to change the value.
For more stuff like this I highly recommend Effective C++ and More Effective C++
I mean, there's books out there like this.
In my own experience, it's a matter of coding enough. You have to try to create something and do it naively. Having done something yourself gives you a reference for when you study programming in books or videoes or when talking to others that you can compare new information to, so you can realize how you could have done things better in your own project. If you don't have any reference experience, you wont learn from the information in the same way. It's part of becoming a programmer that you'll write some crap code.
Try to code some simple desktop application, like a text editor, or some other simple program. Make a list of features it should have - for a text editor, you should be able to input text, modify the input text, save the text and load a text file.
I think the problem is that there are two mutually incompatible teaching requirements here:
1/ Teach nix and C, including fork() and pals
2/ Teach C++ = modern, idiomatic C++ with STL from the outset*, as is generally considered to be the best way.
These are almost entirely separate areas and should be taught separately.
One that Id suggest. Im not a pro, but this book helped me tremendously for foundations and has step by step stuff.
​
https://automatetheboringstuff.com/
​
https://www.youtube.com/user/Albert10110
​
https://www.udemy.com/course/automate/
https://www.amazon.com/Automate-Boring-Stuff-Python-Programming/dp/1593275994/ref=sr_1_2?crid=37AXMKBUDCHVF&keywords=automate+the+boring+stuff+with+python&qid=1574040971&sprefix=automate+the+boring+stuf%2Caps%2C252&sr=8-2
​
https://www.amazon.com/Automate-Boring-Stuff-Python-2nd/dp/1593279922/ref=sr_1_3?crid=37AXMKBUDCHVF&keywords=automate+the+boring+stuff+with+python&qid=1574040971&sprefix=automate+the+boring+stuf%2Caps%2C252&sr=8-3
I've been in a somewhat similar situation. First off, tell your boss that the deadlines aren't happening. They're trying to get all three points of the project management triangle, and it's not going to work. They need to compromise on something. While they're figuring that out, let's get to work.
Step one, if you haven't done this already, is to check everything into version control. You can't do anything about the past, but you can fix the future.
Working Effectively with Legacy Code is a well-reviewed book. Maybe you'll find it more useful than I did - ask your boss to buy it for you. My summary of it is:
You need a working test environment. The one the customer calls production is ideal (for you), but if that's not going to work, you need something as close to it as possible. It is management's job to solve this problem for you so you can do your job. Tell them that you're working with the 4-hr feedback window, and the more time they take to fix that, the longer this is going to take.
You mention that there's no documentation, and that you've read thousands of lines of code but still don't understand how it's pieced together. As you read the code, write the documentation. Be as extensive as you can. This is also a good time to write tests that verify the behavior you think is supposed to happen. And don't just read a file at a time, top to bottom - approach it always with a purpose, eg "how does this page get generated?". This will help you understand the flow, because you'll be tracing it repeatedly, so you'll start to see patterns in how it's all put together.
May the Force be with you.
This book is an amazing book I recommend for anyone who "knows how to write code" and has built a few things. It's a classic. Reading it cover to cover strengthened my coding skills considerably, and lessons I learned from it I apply to every new project I tackle.
[edit:] For example, the DRY principle: Don't Repeat Yourself. Basically, every operation and value in your code needs to be represented once. Two extremely similar functions? Do not copy and paste. Abstract the function slightly and find a way to make it do your two similar operations with the same basic function structure. This keeps your code clean and much easier to modify/maintain.
Need to do the same function in two different classes? Break the operation out into its own class or an abstract class (or other options depending on the language) and make both classes use it, because you'll probably find other similar crossovers that both classes will need. (These cases vary in practice, but you'll get a feel for it.) Hell, on a few occasions I realized after doing this that it was more practical to merge two or more classes into one giant abstract class and write smaller, specific children, and this helped tremendously.
Some situations might arise that this helps:
Sure!
​
I think two classic books to start with is
​
Then I would move onto IDEO's Creative Confidence (https://www.amazon.com/Creative-Confidence-Unleashing-Potential-Within-ebook/dp/B00CGI3DWQ), which documents tons of different UX methods. Also, I haven't read it, but I've heard that Lean UX is a great book (https://www.amazon.com/Lean-UX-Designing-Great-Products-ebook/dp/B01LYGQ6CH).
​
Oh and to learn HTML, CSS, and JS (if you don't know them already), these are AMAZING reads: https://www.amazon.com/Web-Design-HTML-JavaScript-jQuery/dp/1118907442/ref=sr_1_3?crid=1QXNLBZ2V6GL8&keywords=learn+html+css+javascript&qid=1558328362&s=gateway&sprefix=learn+html+css+ja%2Caps%2C-1&sr=8-3
​
With that said, I know books are a big commitment so here's a random assortment of UX articles I've bookmarked over the years to get you started (some may be a little old but should still hold up from a process standpoint):
​
There's a lot more where that came from, so let me know if you get through that and are craving more material.
​
Here are a couple videos as well:
​
Finally, here's a very very short article I wrote myself that provides a quick intro into human centered design: http://www.jdktech.com/human-centered-design/
​
As you dive into this, note that user interface design and user experience design are different things--although they overlap and rely on each other in various ways. You can be a user interface designer (in which case I would recommend different reads), a user experience designer, or both. I'm a full stack designer, which means I specialize in all sides of the product life cycle, including research, validation, design, product management and development.
​
Hope this helps! Let me know if you have any other questions!
I read The Clean Coder: A Code of Conduct for Professional Programmers and it introduced quite a few different concepts and lines of thinking for devs. Good read.
Literally every part about this sounds like an up hill battle. Frankly, no matter what the course of action, a year isn't going to be enough. You've got to start tempering expectations with that now.
The challenge here is rewriting all that Web Forms logic, and this is the piece that is the biggest hurdle. I assume, that since you are working with web forms you don't have any test suite in place, so you're basically walking a tightrope without a net. I also assume that the actual business logic of the application is probably closely intertwined with web forms as well (which I'm assuming because that's how its been nearly every web forms app I've worked with).
Before you start wondering with MVC is the right fit for you, you've got to prepare your code base from moving out of Web Forms. You should pick up Refactoring by Martin Fowler. And begin to move as much code as you can out of code behind files, and into pure C# classes that you can test. Interfaces are your friend. Facades and Adapters are your friend. Unit tests are your friend. You need to have your business logic as portable as possible in order to move away from Web Forms and not be constantly chasing down bugs and unexpected functionality. The more your code-behind is a facade that just takes inputs and calls other classes with them, the better off you'll be
With that out of the way, now we can get in the framework discussion. First off, I don't think a SPA is a good approach here. It'll be too heavy of a lift for your team, and probably not worth the time and effort at this point in time. So you're pretty much left with MVC as an architecture, which is fine, but I think you're going to have some issues with "vanilla" MVC considering the load and the users you're going to have to service, so you're going to have to look beyond that to make this work.
One of the key components to scaling this will be a good cache. If every read needs to hit the database, then you're done. I would recommend using Redis for caching, but an in-memory cache will help you here as well.
I would also strongly recommend looking into CQRS. That stands for Command Query Responsibility Segregation. The high level idea is that requests that need to modify data gets handled by different classes than reading data. This makes it much easier to scale up/out the read side, and also makes it much easier to know when the cache on the write side can be invalidated (since that's coming from the read side).
The challenge with ramping up on CQRS is that its generally presented with a lot of other solutions; MongoDb/Document databases, Event Sourcing, event messaging. Those are good and interesting in their own right, but they are way more than you need right now and CQRS does not require using them.
The last thing I'll touch on here is that if you've got one big ball of mud, you're path to upgrading this going to be very tough. If you can find isolated parts of the application to split off, and test in a different framework, then you'll be much better off. The more isolated sales is from inventory (or whatever you have) the better off you're going to be in the long run. If you can find the time to isolate those components in the application now, rather than try and rewrite the big ball of mud, your future self will thank you.
Surprised Effective Java didn't show up
Edit: Did a little digging and I see a Third Edition seems to be under way for Java 7/8
Edit: these are not affiliate links :)
honestly, pick up this book. it'll up your professionalism a great deal. part of the responsibility of a good coder is to be able to push back to management. not rudely, but they make their money decisions based on tech they don't know, and it's your job to make sure they understand what's possible and what's not instead of just rolling over and taking it.
If you write your code in a meaningful, clean and understandable way itself, comments are almost useless and, in many cases, a source of misunderstanding and mistakes (especially working with other people). If you add too many comments, you need to update them with every single change you make to the code to keep them useful, which is an extra maintenance cost.
Suggestions:
After 10 years of experience as a programmer working on different teams, my opinion is the fewer comments, the better.
I recommend you this book, a classic: https://www.amazon.es/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
Clean Code is widely considered (at least in my circles) as a "must read" position for a pragmatic coder.
Modern C++ (C++11 or later) books are not nearly as plentiful as those for Classic C++, but there are a few notables.
Bjarne's college text may be what you are looking for:
Programming: Principles and Practice Using C++ https://www.amazon.com/Programming-Principles-Practice-Using-2nd/dp/0321992784/ref=pd_sim_14_2/144-7765085-0122037
It is aimed at engineers, which makes it less general, but might be good for you.
Of course his general intro is also updated to C++11.
The C++ Programming Language https://www.amazon.com/C-Programming-Language-4th/dp/0321563840/ref=pd_sim_14_2/144-7765085-0122037
This is aimed at experienced systems programmers, so it may be a bit heavy for students, which makes the Primer (that you mentioned attractive).
C++ Primer https://www.amazon.com/Primer-5th-Stanley-B-Lippman/dp/0321714113/ref=pd_bxgy_14_img_2/144-7765085-0122037
Be certain to get the 5th edition.
Of Scott's books only the latest is Modern.
Effective Modern C++ https://www.amazon.com/Effective-Modern-Specific-Ways-Improve/dp/1491903996/ref=pd_sim_14_2/144-7765085-0122037?_encoding=UTF8
This is less an introduction for students than for Journeymen (Journeypeople?) programmers.
For just plain good programming style consider Ivan's book.
Functional Programming in C++ https://www.amazon.com/gp/product/1617293814
Don't be put off by "Functional." This style of programming will make your students excellent programmers.
There are some modern books of high quality that are niche.
The ultimate guide to templates:
C++ Templates https://www.amazon.com/C-Templates-Complete-Guide-2nd/dp/0321714121/ref=pd_sim_14_1/144-7765085-0122037
The ultimate guide to concurrency:
C++ Concurrency in Action https://www.amazon.com/C-Concurrency-Action-Anthony-Williams/dp/1617294691/ref=pd_sim_14_1/144-7765085-0122037
Some library options:
Despite its name, this is mostly reference. A very good reference.
The C++ Standard Library: A Tutorial and Reference (2nd Edition) https://www.amazon.com/Standard-Library-Tutorial-Reference-2nd/dp/0321623215/ref=pd_sim_14_2/144-7765085-0122037
Arthur's book covers C++17, which makes it one of the most modern on this list:
Mastering the C++17 STL: Make full use of the standard library components in C++17 https://www.amazon.com/Mastering-17-STL-standard-components-ebook/dp/B076CQ1RFF/ref=sr_1_fkmrnull_1
To what extent are you teaching C++ and to what extent are you teaching programing?
Good luck and have fun!
I've been here a few times in my decade-long career.
To start, this isn't something that only happens to junior developers. Trying to approach a large existing code base can be a real challenge, even when you have lots of experience.
You're not going to understand the whole application in a day. Probably not even in a week, and probably not even in a month. On some large code bases, I've regularly run into new code *years* after I first started working on the application.
What I've found helpful is to pick a small part of the application; preferably one that's related to a feature you're trying to add or a bug you're trying to fix. Find what looks like the entry point of that small part of the application. In a web app, it could be a method in a controller class. Or it could be a method in a service class somewhere.
Once you've found that entry point, read through the code one line at a time, and try to make sure you understand what's happening at each point. If the method you're in calls another method/function, jump to that and go through it one line at a time. On code that's particularly complex, I'll grab some sheets of lined paper, and devote one sheet to each method I go through.
As I go through each method, I'll write out the whole thing by hand as pseudocode. In order to do this, I have to understand what the code is doing. Some people might find it more effective to do this in a text editor. I find that there's something about the process of physically writing it out on paper that really helps cement my understanding.
Now, the whole writing out part isn't worth it if you just need to go in and do a quick bug fix. But if you've been handed responsibility for a chunk of code and you'll need to understand it deeply, I've found it to be a useful approach. I think it can still be helpful even if you're not solely responsible for a piece of code, but will have to work on it heavily.
Start by deeply understanding one important part of the code. Then move on to understanding another important part. Soon, you'll start to see patterns and understand how these important bits of code fit together.
If you're not yet sure what the important parts of the code for you to understand are, then a good way to find out would be to look at the repository's commit history to see which files have the most commits over time. The places that change the most often are likely the ones *you* are going to have to change, so they are a good place to begin. You can find instructions on how to do this here:
https://stackoverflow.com/questions/5669621/git-find-out-which-files-have-had-the-most-commits
That assuming your code is in a Git repository. If you team uses Mercurial, you can look up instructions on how to do the same thing. If your team uses Subversion or heck, even CVS, you can probably accomplish the same thing. If your team doesn't use source control at all, then start spiking your morning coffee with rum or Kahlua because that will make your job significantly less painful.
For a look at using Git commit history to find the most important code - and the parts with the most technical debt - I enjoyed a book called Software Design X-Rays.
I've found the book Working Effectively with Legacy Code to be quite helpful in showing me different ways to approach an existing code base. Even if you don't apply all of the techniques the book suggests, I think it's still useful for finding out ways to find 'seams' in the code that you can use as points of attack when refactoring, adding features, or even just choosing a place to start learning a new bit of code.
If your employer will let you expense the cost of eBooks, you might find these interesting. If you can get access to Safari Books Online, both these books are available on there, along with a metric ton of great software development books. You might not need to pay for it - in my city, everyone with a public library account can access Safari for free. Maybe it's similar where you are?
Also, if you have a particularly frustrating day, feel free to come on Reddit and send me a DM. I might just have some useful advice. And if I don't happen to have useful advice on a particularly topic, I'll at least be able to come up with an on-topic smartass remark that will help you laugh and feel better about the code that frustrated you.
Probably start by reading Michael Feather's book about this: Working effectively with legacy code.
http://www.amazon.com/Working-Effectively-Legacy-Michael-Feathers/dp/0131177052/
In addition to what others have said, you need to learn some programming, web and scripting languages + frameworks:
I would make sure to know/learn following in order:
Note: while learning web stuff, try to learn as much as you can about how the web works, technologies used, etc. Your networking knowledge should help here
To practice things security related:
Black Friday deals:
https://www.reddit.com/r/AskNetsec/comments/9yza56/2018_list_of_black_friday_netsec_resources/
https://pastebin.com/aLBfQT6H
​
​
Extra books: https://nostarch.com/hacking2.htm (The art of exploitation) (not a super beginner but it's on sale now)
Disclaimer: I am a software engineer, so the security field is new to me as well but for now I am doing hackthebox :).
Much of this stuff is learnable outside of work, too, at least at a superficially-passable level. Trust me.
Pick up a few seminal books and read them with vigor. That's all you need to do.
Here are some books I can personally recommend from my library:
Software Design
​
Software Industry
I'm amazed that no-one has mentioned this.
The absolute best book for you is Accelerated C++ by Andrew Koenig and Barbara E. Moo.
It is targeted at people who already know another language, especially Java or Python.
https://automatetheboringstuff.com/
(dead tree version of same)
Refactoring. I've known many a coder that loves to engage in this most macho of disciplines. Funny thing is, is that many such coders don't use any unit testing. As anyone who has read or at lest skimmed Refactoring
knows that one should not even contemplate making any changes without a solid test suite to catch the inevitable bugs.
Refactoring isn't about engaging in brutal combat with your code. Refactoring is about careful reshaping.
Get Effective Java by Josh Bloch.
Sure, like most people, I started with Python. I didn't start on codeacademy though, I started on program arcade games.
By the way, I should mention that at the time, I was a night manager at a Hostel so I got LOADS of free time to myself, and then when I got home I had even more free time so there was lots of time to practice.
In the first 3-4 months I learnt the basics of functions and classes and how to use them. After that time had passed, I dug deeper and bought Learning Python and read that a lot. I learnt pretty quickly about the cool things about Python like list comprehensions, anonymous functions (Lambdas), operator overloading, all that stuff. By the way, that book is not a beginner's book, it's a book on pretty much everything about Python
I kept programming in my spare time, I made a lot of crappy things and gradually my code got cleaner and easier to maintain. I made things that interested me, like a MIDI parser, a reddit bot that converts images to ascii Python C#, a bruteforce directory scanner and some other stuff. As you can see, I was pretty busy. This is what's important. By all means, do Project Euler and participate in Daily Programmer but don't expect it to nail you a job. That stuff is useful, but a lot of those are just algorithms, not programs that will impress the person interviewing you (who might not be technical in the first place).
Eventually I just sort of 'got' Python, and decided to learn other languages that interested me. For some reason, that was C. Choosing to learn C was a really good choice but at the time I found it too difficult so I gravitated towards slightly newer languages like C#.
When I started to think my programs had some sort of quality to them I applied for jobs. I looked at job listings and if I saw a requirement that I didn't have i.e. (Version Control) then I'd learn it.
The caveat with learning Python at the time, was that it left me pretty useless (bare in mind I live in Wales in the UK, not uber-progressive,technology wise). The majority of the listings wanted PHP, or VB.NET (yes you read right)
Eventually I got my lucky break with a duo of awful businessmen, they didn't know what they wanted and I didn't know how to deliver, but I tried and I learnt a butt-load as I tried to make their product. Their product was an entire website (frontend, backend and DB) that was to start off small and grow internationally, and they wanted it in 10 weeks... Needless to say, they didn't keep me on (surprise surprise) but with that experience I managed to nail a decent job with other developers using a similar set of skills. By the way that job with businessmen was in VB.NET, not an awful language but why not C#?
The new job is good, I create backends for websites, create frontends from photoshop files that are handled by our designer and I also create plugins for an in-house CMS (Think Joomla and similar stuff). This current position is in PHP, it has it's quirks - naming standards vary wildly, the $, foreach loop is backwards in syntax, -> instead of ., and a bunch of other stuff, but it's easy to use.
As it stands currently, I'm working on trying out different architectural patterns. The good thing about the position I'm in is that it's lots of small projects so I can do something new with each new project. Maybe I'll try a different design pattern, maybe I'll go MVP over MVC, I'm pretty much free to learn and do as I want since there is no codebase (well there is a codebase, but I can still try out new methods) for a module that doesn't exist.
TL;DR
Hopefully I answered what you wanted
Every quality software should have tests. So...
Read the unit tests / features tests first. Those will show you how a specific piece of the code works.
Also:
There are a lot to learn and if you really like programming you will never stop learning.
I like these and would add:
3) Given how cheap they got lately, I would suggest to use at least two screens for work. More screen real estate equals more efficiency.
4) Master your tools. Memorize the shortcuts your editor provides (or learn Vim :) ), learn to take full advantage of your IDE's debugging capabilities, and so on.
...and regarding this...:
> Design patterns.
Refactoring - Improving the Design of Existing Code is a great book on this topic.
So basically Uncle Bob forgot how to actually refactor, and didn't bother whipping up his copy of Refactoring?
Automated refactoring tool are a good thing, because (especially in statically typed languages) they make refactoring safer (but not safe, if you use e.g. code generation or reflection, your refactoring browser won't help you), more systemic, more systematic and much faster.
But they were never necessary, the basic concepts of refactoring were tool-less, and Refactoring lists only manual recipes (with a discussion on refactoring browsers in another chapter), some of them -- if I remember well, it's been some time since I've read it -- not even being automatically implementable.
Thank you all for your responses! I have compiled a list of books mentioned by at least three different people below. Since some books have abbreviations (SICP) or colloquial names (Dragon Book), not to mention the occasional omission of a starting "a" or "the" this was done by hand and as a result it may contain errors.
edit: This list is now books mentioned by at least three people (was two) and contains posts up to icepack's.
edit: Updated with links to Amazon.com. These are not affiliate - Amazon was picked because they provide the most uniform way to compare books.
edit: Updated up to redline6561
It depends on whether you're a beginner to C++, a beginner to programming or both. It also depends on whether you prefer a tutorial style -- where you read closely and walk step by step with the author, or a reference -- where you skim, go at your own pace, and follow up when you need more details.
Accelerated C++ is more of a short introduction that hits all the broad strokes. It's good for someone who's already very adept but just needs to get into the mindset of C++.
Principles and practice is a tutorial style book suitable for an introductory course, and isn't a bad choice. The C++ Programming Language is more of a reference style and would be good for people who really prefer that direction.
I've read parts of How to Program Java and definitely was not impressed -- not sure how 9th ed of C++ stacks up.
I'm assuming a beginner is new to programming, but by virtue of choosing C++ enjoys the technical details that allows you to make the most of the language. My recommendation for this kind of user by far and away is C++ Primer by Lippmann, Lajoie, Moo (not to be confused with Primer Plus). This book (3rd ed) was what made me fall in love with the language in university.
It's written by people who were deeply involved in the standards, wrote actual compilers, and know how to present the material in ways that are relevant to the student. The 3rd ed also had sections that went further and explain the underlying compiler mechanism for a given feature which I found so insightful. They somehow managed to marry a high-level tutorial style narrative with important low level technical details that very much mirrors the style of the language itself. The 3rd ed also explicitly called out C++ as a mutli-paradigm language where functional style was possible (which was my first introduction to the concept of functional programming).
I'm not sure how much of that book survives in the 5th ed, but either way I recommend you read the book yourself and see if it's something that resonates for you. I'm looking through a copy of 5th ed right now, and it looks like much of that spirit is still alive. The down side is it appear it's still on strictly C++11, which given the size of the language and intended audience, I don't think is a fatal weakness.
If you want a complement to C++ Primer, Stroustrop's reference is the most complete, but to be honest I prefer C++ Reference for a working programmer.
I highly recommend ditching IDEs entirely for learners precisely because they make it harder to detect and learn from your mistakes. Get a copy of a linux distro, or install XCode command line tools, and invoke GCC/Clang directly. By the time you need to move into larger projects you'll have developed your own opinions on build systems/IDEs.
A good book for you would be clean code. I'm only part way into it, but it's a really good resource for learning better code practices. You won't find much commenting in there, however, as their philosophy is that you shouldn't need comments if you do it right. It might be a good place to start if you're willing to look for good commenting practices elsewhere
I don't really like the term "design your system using interfaces" because it doesn't tell you why. It's a generic idea without any context.
It is better to start with a principle, like Dependency Inversion. Dependency Inversion says you should separate your code from its external dependencies. This is good, because it keeps your code isolated and not dependent on the particular details of things like storage.
Does your application use MySql? Does it use MongoDB? It doesn't matter. In your interface, you can specify query methods for objects from a data store, and a method to save objects to your data store. Then implement the interface specifically for the data store. Your interface could be called
FooRepositoryand the implementationMySqlFooRepositoryorMongoFooRepository. I dislike interfaces calledFooRepositoryImpl. This strongly suggests an interface isn't necessary.Interfaces are contracts that help you preserve your design and to explain what you need out of external dependencies.
Interfaces are good, but so are classes. Don't overuse interfaces, because indirection isn't always necessary or good. It can make your code impossible to follow and understand.
Start by learning principles like SOLID, which will help you understand where usage of interfaces makes sense. Agile Patterns, Principles and Practices is the best book I've read about this. Another book which does a great job of explaining how to properly use interfaces is Growing Object Oriented Software Guided By Tests.
My main hobby is reading textbooks, so I decided to go beyond the scope of the question posed. I took a look at what I have on my shelves in order to recommend particularly good or standard books that I think could characterize large portions of an undergraduate degree and perhaps the beginnings of a graduate degree in the main fields that interest me, plus some personal favorites.
Neuroscience: Theoretical Neuroscience is a good book for the field of that name, though it does require background knowledge in neuroscience (for which, as others mentioned, Kandel's text is excellent, not to mention that it alone can cover the majority of an undergraduate degree in neuroscience if corequisite classes such as biology and chemistry are momentarily ignored) and in differential equations. Neurobiology of Learning and Memory and Cognitive Neuroscience and Neuropsychology were used in my classes on cognition and learning/memory and I enjoyed both; though they tend to choose breadth over depth, all references are research papers and thus one can easily choose to go more in depth in any relevant topics by consulting these books' bibliographies.
General chemistry, organic chemistry/synthesis: I liked Linus Pauling's General Chemistry more than whatever my school gave us for general chemistry. I liked this undergraduate organic chemistry book, though I should say that I have little exposure to other organic chemistry books, and I found Protective Groups in Organic Synthesis to be very informative and useful. Unfortunately, I didn't have time to take instrumental/analytical/inorganic/physical chemistry and so have no idea what to recommend there.
Biochemistry: Lehninger is the standard text, though it's rather expensive. I have limited exposure here.
Mathematics: When I was younger (i.e. before having learned calculus), I found the four-volume The World of Mathematics great for introducing me to a lot of new concepts and branches of mathematics and for inspiring interest; I would strongly recommend this collection to anyone interested in mathematics and especially to people considering choosing to major in math as an undergrad. I found the trio of Spivak's Calculus (which Amazon says is now unfortunately out of print), Stewart's Calculus (standard text), and Kline's Calculus: An Intuitive and Physical Approach to be a good combination of rigor, practical application, and physical intuition, respectively, for calculus. My school used Marsden and Hoffman's Elementary Classical Analysis for introductory analysis (which is the field that develops and proves the calculus taught in high school), but I liked Rudin's Principles of Mathematical Analysis (nicknamed "Baby Rudin") better. I haven't worked my way though Munkres' Topology yet, but it's great so far and is often recommended as a standard beginning toplogy text. I haven't found books on differential equations or on linear algebra that I've really liked. I randomly came across Quine's Set Theory and its Logic, which I thought was an excellent introduction to set theory. Russell and Whitehead's Principia Mathematica is a very famous text, but I haven't gotten hold of a copy yet. Lang's Algebra is an excellent abstract algebra textbook, though it's rather sophisticated and I've gotten through only a small portion of it as I don't plan on getting a PhD in that subject.
Computer Science: For artificial intelligence and related areas, Russell and Norvig's Artificial Intelligence: A Modern Approach's text is a standard and good text, and I also liked Introduction to Information Retrieval (which is available online by chapter and entirely). For processor design, I found Computer Organization and Design to be a good introduction. I don't have any recommendations for specific programming languages as I find self-teaching to be most important there, nor do I know of any data structures books that I found to be memorable (not that I've really looked, given the wealth of information online). Knuth's The Art of Computer Programming is considered to be a gold standard text for algorithms, but I haven't secured a copy yet.
Physics: For basic undergraduate physics (mechanics, e&m, and a smattering of other subjects), I liked Fundamentals of Physics. I liked Rindler's Essential Relativity and Messiah's Quantum Mechanics much better than whatever books my school used. I appreciated the exposition and style of Rindler's text. I understand that some of the later chapters of Messiah's text are now obsolete, but the rest of the book is good enough for you to not need to reference many other books. I have little exposure to books on other areas of physics and am sure that there are many others in this subreddit that can give excellent recommendations.
Other: I liked Early Theories of the Universe to be good light historical reading. I also think that everyone should read Kuhn's The Structure of Scientific Revolutions.
I think the two suggestions you'll see the most will be:
Code Complete
Pragmatic Programmer
I'm sort of in the same boat as you, except with an aero and physics background rather than EE. My approach has been pretty similar to yours--I found the textbooks used by my alma mater, compared to texts recommended by MIT OCW and some other universities, looked at a few lists of recommended texts, and looked through similar questions on Reddit. I found most areas have multiple good texts, and also spent some time deciding which ones looked more applicable to me. That said, I'm admittedly someone who rather enjoys and learns well from textbooks compared to lectures, and that's not the case for everyone.
Here's what I gathered. If any more knowledgeable CS guys have suggestions/corrections, please let me know.
Full disclosure: I haven't actually read more than the preface of any of those books. Software engineering topics are more directly applicable to me than CS topics right now, so here are some that I've actually started reading:
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!
I had a lot of similar issues early on in my career. I seem to type faster than I think, and a lot of little things somehow made it into my code that I wouldn't notice until much later, when I had a lot more code debug through.
Getting into the habit of Test-Driven Development pretty much solved this for me. By writing unit tests in expectation of the functionality of the code I wanted to write, I would prevent myself from building on top of code with bugs or small errors.
A lot of people think TDD takes twice as much time because you write roughly twice as many lines of code, but I was drastically underestimating how much time I was spending debugging. My code gets written and merged in half the time it used to take, and having my code reviewed takes almost no time at all.
TDD is by far the best remedy for small, easy-to-overlook mistakes, but it also forces you to break down problems into much smaller units than you might instinctively. I find that this also helps me solve problems faster, because I prevent myself from immediately attacking the first problem I see, which may actually be a combination of 2-3 problems (which I may have already solved somewhere else). My code is more functional, more organized, less repetitive, and problems get solved much faster.
I highly recommend reading Growing Object-Oriented Software Guided by Tests.
Don't give up just yet, keep looking.
Do you have a portfolio? if not try to work on a project of your own so you can have something to show.
And if you are considering improving your java skills try work with libraries like:
With spare time I would also recommend you to read:
https://www.amazon.com/Pragmatic-Programmer-Journeyman-Master/dp/020161622X/ref=nodl_
https://sites.google.com/site/steveyegge2/being-the-averagest
http://wiki.c2.com/?SoftwareDesignPatterns
https://en.m.wikipedia.org/wiki/SOLID_(object-oriented_design)
Been a developer for 18 years, never had a mentor, but these ideas/concepts I found insightful and enlightening.
There are no good online C++ tutorials. If you want to learn C++ you'll need a good book, C++ Primer 5th Ed. is great for beginners (it's recommended in the wiki!).
You have a long journey ahead of you, but here goes :D
Beginner
C++ Primer: One of the better introductory books.
The C++ Standard Template Library: A Tutorial and Reference: Goes over the standard template library in fantastic detail, a must if you're going to be spending a lot of time writing C++.
The C++ Programming Language: Now that you have a good idea of how C++ is used, it's time to go over it again. TCPPL is written by the language's creator and is intended as an introductory book for experienced programmers. That said I think it's best read once you're already comfortable with the language so that you can full appreciate his nuggets of wisdom.
Intermediate
Modern C++ Design: Covers how to write reusable C++ code and common design patterns. You can definitely have started game programming by the time you read this book, however it's definitely something you should have on your reading list.
C++ Templates: Touches on some similar material as Modern C++ Design, but will help you get to grips with C++ Template programming and how to write reusable code.
Effective C++: Practical advise about C++ do's and dont's. Again, this isn't mandatory knowledge for gamedev, but it's advice is definitely invaluable.
Design Patterns: Teaches you commonly used design patterns. Especially useful if you're working as part of a team as it gives you a common set of names for design patterns.
Advanced
C++ Concurrency in Action: Don't be put off by the fact I've put this as an "advanced" topic, it's more that you will get more benefit out of knowing the other subjects first. Concurrency in C++11 is pretty easy and this book is a fantastic guide for learning how its done.
Graphics Programming
OpenGL: A surprisingly well written specification in that it's pretty easy to understand! While it's probably not the best resource for learning OpenGL, it's definitely worth looking at. [edit: Mix it in with Open.gl and arcsynthesis's tutorials for practical examples and you're off to a good start!]
OpenGL Superbible: The OpenGL superbible is one of the best ways to learn modern OpenGL. Sadly this isn't saying much, in fact the only other book appears to be the "Orange Book", however my sources indicate that is terrible. So you're just going to have suck it up and learn from the OGL Superbible![edit: in retrospect, just stick to free tutorials I've linked above. You'll learn more from them, and be less confused by what is 3rd party code supplied by the book. Substitute the "rendering" techniques you would learn from a 3d book with a good 3d math book and realtime rendering (links below)]Essential Mathematics for Game Programmers or 3D Math Primer for Graphics and Game Development: 3D programming involves a lot of math, these books cover topics that OpenGL/DirectX books tend to rush over.
Realtime Rendering: A graphics library independent explanation of a number of modern graphical techniques, very useful with teaching you inventive ways to use your newly found 3d graphical talents!
This is a good start to get a taste of good code:
http://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882/ref=sr_1_1?ie=UTF8&qid=1456913184&sr=8-1&keywords=clean+code
Many developers recognize this practices and value them very much.
I'm going to start by assuming this may be maintained by another person at some point in the future. First off, naming. Although it is kinda targeted towards Java, the majority is directly applicable to C#. Clean Code. The underscores and you prefixing an abbreviation for the type should be changed. An example would be:
i_orderID
Changes to:
OrderId
because of the fact that it is a public property, and you've already told us it is an Int when you declared it. Doing this will allow others to maintain your code with less headache. https://msdn.microsoft.com/en-us/library/ms229045(v=vs.110).aspx is an MSDN article that goes over some of it.
Next, spaces in the folder names, you should avoid that for the same reason above, use PascalCase, no spaces, no hyphens, no underscores if possible.
You have no guard clauses in there. An example of adding one in would be (Line 31 'DataObjects.cs):
if (string.IsNullOrEmpty(displayLine1)) throw new ArgumentNullException("displayLine1");
Favor guard clauses over exception handling wherever possible. When you need to handle exceptions, handle them specifically. If the code you are calling can throw an InvalidOperationException, favor catching that over just Exception. Exceptions should be exceptional, not a common occurrence in your code, guard clauses help with that. Another example would be (Line 96 'Program.cs'):
if (File.Exists(s_directory + @"\Bricks.xml") { ...the rest of the code that uses that file here }
Use meaningful names. 'displayLine1' as a constructor parameter is ambiguous. Sometimes it makes sense to shorten some of the names as well; 'customerWhoPurchasedId' could just be 'customerId'.
In DataObjects.cs, you are returning '-1' as an error, I would use something more meaningful than a number. If you are going to use a number like that, use an enum so that you can read your code using friendly names, '-1' is ambiguous, but something like BrickSearchResult.Empty is not.
Style out of the way, now let's move on to data. You are a database guy. I would suggest using a database to store the data over an xml file.
Next. You are doing a ton of work in your application's main constructor. Move that code out of there, and let it initialize the app unimpeded. People debugging your code later will thank you. I would suggest using the Form_Loaded or whatever the Forms equivalent for Window_Loaded is.
On a general note, follow the principle of having each small piece of code do one thing, and one thing only. Your main class is also responsible for data access, it should not be. You should have separate classes for that, this is called 'separation of concerns'. Your CRUD operations should all be in the same class. Each class should have its own file whenever possible. So 'DataObjects.cs' would be split into 'Customer.cs' and 'Brick.cs'. Keep in mind that you can use folders in your solution as well to keep things a bit more organized.
You are welcome to PM me if you have other questions.
I guess I'm going to go ahead and be "that guy".
Don't aim to work with a specific language.
I feel you should reframe your goal to be a "problem solver" that knows how to pick and use various tools to solve a problem. C++ may be one of those tools. Maybe C. Maybe Python. Maybe Java. You want to develop your skill set to be flexible enough to adopt the right tool for a job. Now, that's not to say you can't be a language expert. Language experts are very valuable and becoming one is a perfectly reasonable goal. That said, I think you'll find that you have many more opportunities when you remain flexible.
With that out of the way, I would say good next steps for continued C++ mastery are to read and understand Scott Meyers' excellent books:
Also go through the CppCoreGuidelines.
Beyond the language, make sure you know your standard data structures and algorithms.
Get the book Working Effectively with Legacy Code. It's entirely how to deal with this situation, and might be better titled as How to Test Untestable Code.
Basically, the advice is this: get the system under test NOW, then you can make changes. If there's anything you need to change, try to get it unit tested. Whenever you break something, before you fix it, write a unit test.
Slowly, the system will become better. You'll still have a lot of hair-raising problems, but each time you add a test, you'll be more confident, because you'll know that some things still work.
The problem here will be if the professor cares enough to give you time to make any changes that aren't adding new functionality.
Clean code by Robert Martin AKA Uncle Bob.
https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
He also has a website with videos that go over topics from the book and more:
https://cleancoders.com/videos
Just keep learning for now and focus on building your understanding of programming, rather than syntax or following convention. Despite what a lot of people tend to say, unlearning habits in not hard, especially as a beginner. Focusing too much on best practices early on will be an unnecessary distraction when you already have a lot of new things to try and get your head around.
When you get more proficient and start needing to worry about best practices, read Clean Code.
La scelta del linguaggio di programmazione dipende molto dal contesto e dalla applicazione specifica. R é ottimo per l'analisi statistica, ma appunto si adatta solo a quello.
Per iniziare, mantenendo una forte connessione con quello che desideri studiare, ti suggerisco python.
Leggi "Python Data Science Handbook: Essential Tools for Working with Data" e "Learning Python"
Impara a manipolare e filtrare dati con Pandas, Numpy, Scipy,
Impara a mostrare dati preacquisiti con matplotlib, seaborn, bokeh,
o dataset che possono evolvere rapidamente con pyqtgraph
Mi stavo quasi dimenticando, per analisi statistiche uso Statsmodels
Quanto tempo serve? Non lo so. Io imparo linguaggi e librerie nuove ogni giorno perchè ogni mese disegno qualcosa di nuovo, diverso, migliorato.
Edit: aggiungo un commento finale. Arrivati ad un certo livello di affinità con la programmazione, il linguaggio di programmazione scelto non importa quanto la disponibilità di librerie affidabili, ben documentate, e ben mantenute. Dal mio punto di vista avere buone librerie è essenziale perché creare ex novo una libreria ha un costo {temporale, di skills, di focus, etc..} che spesso preferisco allocare diversamente.
wow. I'm surprised these two aren't listed yet:
Pragmatic Programmer - this one's at the top of my list. I think that every single programmer should read this book.
Effective Java - although it's written for Java there's some great fundamentals in there.
a lot of people also mentioned Clean Code - while some things in there are important, I personally don't agree with everything that Bob writes about
No. C++ is somewhat unique in that you really get what you pay for; I've not seen a single good online resource to learn it. Every tutorial I have ever looked at contains misinformation and bad practice.
The best way to learn C++, if you have done programming before, is with a book like Accelerated C++ or another from this list. If I am to consider you a complete novice, I would suggest you pick up Python or Ruby again before delving in to C++. There are good resources online for those and they are linked in the sidebar and FAQ.
Effective Java by Joshua Bloch is a really good book and definitely worth reading if you're using an object-oriented language, not just Java. It helped me immensely when I was starting out with how to think about my code and my designs.
By Essential Java, I take it you mean Effective Java, right?
Does not include Java 8 but https://www.amazon.co.uk/Effective-Java-Second-Joshua-Bloch/dp/0321356683 fits the bill of the Java k&R
You mention you have a very experienced team around you, this is your best resource. When I started my first coding job, the people around me really helped me become a much better developer. Ask for advice when you are stuck, think about best practices and sit with them and do the code reviews together. If they are writing good code then use their code as a guide for your own. You will soon learn the skills for yourself and realise that it's not as daunting as it seems as long as you can code basic programs. Something you can do to get a better feel for how your basic programs create something larger is to get them to walk you through the architecture.
One thing I did when I started was ask my team leader where I could improve and he recommended me some books. Have a look at head first design patterns, clean coder and growing-object-oriented-software. These are Java based but are applicable to any language.
http://www.growing-object-oriented-software.com/
http://www.amazon.co.uk/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
http://www.amazon.co.uk/Head-First-Design-Patterns-Freeman/dp/0596007124
Go read Clean Code: A Handbook of Agile Software Craftsmanship and write beautiful code yourself.
I keep a copy of this book on my desk. I've never read it but I'll be damned if it's not sitting on my desk.
Working Effectively with Legacy Code
Might be a good place to start. Don't rebuild in one hit, isolate functionality, wrap with tests and abstraction layer, rebuild one component at a time
A classic text for this situation is Working Effectively with Legacy Code by Michael Feathers. Legacy code is a different ball-game than relatively clean code-bases, and has its own set of strategies. As it happens, there is a timely episode of the SE Radio podcast as well.
> I know programming
I have a checklist I usually bring out at this point :) You should know:
If you confident you have all this you'll probably want to start learning about design patterns and decoupling techniques. This free online book is amazing, and I would recommend it to everyone:).
Other books like Clean Code and The Art of Unit Testing have helped me a lot too.
With coding, it because more about creating code that is easy to change. I would also recommend using StrangIoc along with MVC to achieve decoupled, clean code:)
I recommend picking up a copy of either Programming Principles and Practice Using C++ or C++ Primer.
​
https://en.cppreference.com/w/ is a reference website, and is the goto resource for quick documentation lookups, etc. However, when learning C++ from scratch, a book is simply the best way to go.
The resource seems very extensive such that it should suffice you plenty to be a good software engineer. I hope you don't get exhausted from it. I understand that some people can "hack" the technical interview process by memorizing a plethora of computer science and software engineering knowledge, but I hope you pay great attention to the important theoretical topics.
If you want a list of books to read over the summer to build a strong computer science and software engineering foundation, then I recommend to read the following:
The general theme of this list of books is to teach a hierarchy of abstract solutions, techniques, patterns, heuristics, and advice which can be applied to all fields in software engineering to solve a wide variety of problems. I believe a great software engineer should never be blocked by the availability of tools. Tools come and go, so I hope software engineers have strong problem solving skills, trained in computer science theory, to be the person who can create the next big tools to solve their problems. Nonetheless, a software engineer should not reinvent the wheel by recreating solutions to well-solved problems, but I think a great software engineer can be the person to invent the wheel when problems are not well-solved by the industry.
P.S. It's also a lot of fun being able to create the tools everyone uses; I had a lot of fun by implementing Promises and Futures for a programming language or writing my own implementation of Cassandra, a distributed database.
I'm actually writing a Python book for non-programmers on this exact topic. Automate the Boring Stuff with Python
It will be free to download under a Creative Commons license when published. You can read the description (and later the book) from here: http://automatetheboringstuff.com/
>I have some questions about courses andsubjects for computer engineering ( Software Engineering)
CE and SWE are....a little different so I'll just talk to both a little bit.
CE is closer to Electrical Engineering specializing in Computers so you'd take more hardware oriented courses. Most CE curriculums [I've seen] take you through Circuit Theory, Electronics, Digital Systems, Signal Processing, Computer Organization (aka CPU design), Computer Networks, Embedded Systems, etc.
SWE is closer to applied computer science and is more about building applications and the software development process. So you'd start going through a lot of the early Comp Sci courses (Intro to Programming, Language Processors, Data Structures and Algorithms, Operating Systems, etc.) then you'd start leaning towards topics more closely related to building an actual piece of software like Software Project Management or Quality Assurance.
>Are they any books that you recommend to a complete noob ? Internet links ?
Who reads books?Other Tips:
Teach. Yourself. Git.
Video Tutorials:
Articles & Websites:
I think the pragmatic programmer is exactly the right book for you.
It covers a lot of things like testing, general coding concepts, version controll, etc.
did you by any chance write this book?
http://www.amazon.com/Accelerated-C-Practical-Programming-Example/dp/020170353X
edit Supposedly this guy is OG in data science. http://www.datasciencecentral.com/profiles/blogs/hitchhiker-s-guide-to-data-science-machine-learning-r-python
My friend has a bio background and doing well as a data scientist consultant. I wouldn't shy away with a lack of math.
I'm still an amateur, so take this with a grain of salt.
I'd also like to share my strategy for learning data science so far.
I have a math background, which is useful but not required. Knowing linear algebra and differential equations, some analysis stuff is useful for developing a deeper intuition into how the machine is learning, but not necessary. IMO data science is a life long journey as it can be applied to many fields. It may be useful to learn more math later on as it get's deeper, but surface level knowledge should suffice.
For linear algebra, I've found the first lecture to be the most useful. http://ocw.mit.edu/courses/mathematics/18-06-linear-algebra-spring-2010/video-lectures/ It basically describes how we can translate lines into vectors and find solutions. It may be useful for continue learning, but in the beginning I believe surface understanding should suffice. If you're looking to build new data analytic tools, understanding the maths at depth is a must. But if your goal is to apply the tools already in existence, you can get by with a brief understanding.
For example, I have a weak statistics background; for the things I don't know I look them up on wikipedia, various sites, etc. The goal is not necessarily to learn the material as you would for an exam, but to develop a broader understanding of what the material is and how it is relates to machine learning. When I read this material I probably retain only 5-15% of the information, but I read enough to let me move on. Never get stuck on one piece of information for too long. I've found if I get stuck, I can move on and the brain just kind of figures out how it fits into the puzzle.
With your background Andrew Ng's course on coursera https://www.coursera.org/learn/machine-learning should be suitable.
I watch these videos only once on 2x speed. My goal is not to retain the information but to index it. Much of what is useful will be learned by practice, by watching the videos on 2x it's like skimming a text. It allows you to index, that way you know where to look if you need greater depth in the future. For example, you don't have to memorize the cost function, but it's important to know why the cost function is constructed the way it is, and what it's use is.
I then supplement by reading this: http://neuralnetworksanddeeplearning.com/
and doing these problems http://www.cs.cmu.edu/~tom/10601_fall2012/hws.shtml
This is the most useful resource I've found tbh:
http://www.kdnuggets.com/
I have a weak programming background, so for learning python I've found this text useful for practice and learning the language: https://www.amazon.com/Automate-Boring-Stuff-Python-Programming/dp/1593275994?ie=UTF8&Version=1&entries*=0
This text is very basic, useful in general if you don't have a compsci/compeng background, but doesn't have direct applications for data science. For a more data focus wrt python: https://www.coursera.org/specializations/python . You do not have to pay for any of these courses. Just search for the specific course and enroll, for example, https://www.coursera.org/learn/python-data
That's pretty much where I'm at.
I believe the most important thing is to train our brains to think as the machine would. It's important to utilize our intuition and natural parallel abilities of the brain, as ultimately these are the techniques we are attempting to replicate.
Python crash course is excellent and the 3 books I would recommend for anyone just starting with python would be:
Python Crash Course (I like this book but I think it can be skipped)
How to Think Like a Computer Scientist
Problem Solving with Algorithms and Data Structures using Python
If you are more into theory I would choose:
Learning Python, 5th Edition
I prefer Uncle Bob's view:
> It is well known that I prefer code that has few comments. I code by the principle that good code does not require many comments. Indeed, I have often suggested that every comment represents a failure to make the code self explanatory. I have advised programmers to consider comments as a last resort.
Other times he puts it more bluntly:
>Comments are always failures. We must have them because we cannot always figure out how to express ourselves without them, but their use is not a cause for celebration.
or
>"Every time you write a comment, you should grimace and feel the failure of your ability of expression."
I know it's not always practical, but I like Uncle Bob's extremely demanding perspective, because I feel it sets a really high bar and struggling to work toward it is something that stretches me.
If this is a wildly shocking view, I highly recommend picking up a copy of Uncle Bob's book Clean Code which I learned about from this IRDC talk. I saw that talk, bought the book, read it, and my views were changed. I now refactor a lot more and comment a lot less.
Uncle Bob's minimally commented code doesn't come cheap though, he spends a ton of cycles after the code works, retooling it specifically to make it readable.
Also, for the record, I ain't no Uncle Bob. Don't misunderstand me as saying I live up to his standards please!!
If you need to be neo to read code, then that code isn't written well.
Code is read by humans not machine.
So write code like a sentence.
I recommend you to read clean code by Uncle Bob. Something they don't really teach you in school.
Code: The Hidden Language of Computer Hardware and Software
The Mythical Man-Month
Peopleware: Productive Projects and Teams
Gödel, Escher, Bach: An Eternal Golden Braid
The Pragmatic Programmer: From Journeyman to Master
Coders at Work: Reflections on the Craft of Programming
Read through this entire book before your program anything big.
The biggest hurdles I had motivating myself to work on a project was never coding itself. It was always setting up the compiler, IDE, environment, finding something to work on, etc. The biggest one for me is blank page syndrome.
You don't need to convert to linux if you don't want to but it is good to get some experience in it if you can. I spent sometime setting up a headless Ubuntu server to manage my torrents and be network storage. It took a lot of time starting from scratch but the experience has helped me out.
http://www.ubuntu.com
http://www.reddit.com/r/linuxquestions
http://ubuntuforums.org/
If you want to continue with Java (which is a good choice). I believe the most popular IDE is Eclipse. It has great plugin support and has been used everywhere I've been. You can use it for development on android phones as well if you want to play around with mobile development.
http://www.eclipse.org
http://developer.android.com/tools/sdk/eclipse-adt.html
If your college is like mine, most of the later courses in computer science will not involve much coding at all but will involve a lot of math and knowing popular solutions to common problems (sorting, searching, graph theory, combinatorics). If you feel like you need to brush up on a language, there are a lot of web resources and books to help you.
http://www.codecademy.com
http://www.amazon.com/Effective-Java-Edition-Joshua-Bloch/dp/0321356683
http://www.amazon.com/Head-First-Java-Kathy-Sierra/dp/0596009208/ref=sr_1_2?s=books&ie=UTF8&qid=1382580434&sr=1-2&keywords=head+on+java
Computer science and software development is a broad field which makes scaling it daunting at times. The only way to make it less daunting is to just dive in and do it. Pick a project and work on it. You will encounter problems you have no idea how to solve and that's great because now you've found something you can learn (usually through Google).
Solve problems in manageable bits. If you try to implement your whole program at once it will seem impossible. Implement small portions of your project at a time. Trying to create a Java chat client? Just work on getting some basic sockets to work and build a library you'll be able to use going forward. This will make the goals seem manageable and help you modularize your code. It helped me with not feeling overwhelmed about my project's scope.
I hope I didn't sound condescending. I just wanted to share some things that have helped me. I don't think you are in a bad spot, you just need to stay motivated and find some things to work on to help you learn. If you have any specific questions I can try to help out, but there are other people on this sub that are far more knowledgeable than me.
Stupid question on my end perhaps but have you ever read How to Think Like A Programmer?
Think Like a Programmer: An Introduction to Creative Problem Solving https://www.amazon.com/dp/1593274246/ref=cm_sw_r_cp_apa_sjOCAbTSAJPKT
If you go with C++ read Accelerated C++.
Clean Code
The Jez Humble / David Farley book on Continuous Delivery is a must read from a standpoint of teams that deliver solutions in an automated way. More oriented towards software developers than operations / IT but really a must read for both types of folks for us to all come together as "DevOps".
edit: Amazon Link: https://www.amazon.com/Continuous-Delivery-Deployment-Automation-Addison-Wesley/dp/0321601912
I would recommend C++ Primer 5th Edition http://www.amazon.com/Primer-5th-Edition-Stanley-Lippman/dp/0321714113 to get up to speed with C++11 then probably Stroustrup afterwards.
Good on you for looking to grow yourself as a professional! The best folks I've worked with are still working on professional development, even 10-20 years in to their profession.
Programming languages can be thought of as tools. Python, say, is a screwdriver. You can learn everything there is about screwdrivers, but this only gets you so far.
To build something you need a good blueprint. For this you can study objected oriented design (OOD) and programming (OOP). Once you have the basics, take a look at design patterns like the Gang of Four. This book is a good resource to learn about much of the above
What parts do you specify for your blueprint? How do they go together? Study up on abstract data types (ADTs) and algorithms that manipulate those data types. This is the definitive book on algorithms, it does take some work to get through it, but it is worth the work. (Side note, this is the book Google expects you to master before interviewing)
How do you run your code? You may want to study general operating system concepts if you want to know how your code interacts with the system on which it is running. Want to go even deeper with code performance? Take a look at computer architecture Another topic that should be covered is computer networking, as many applications these days don't work without a network.
What are some good practices to follow while writing your code? Two books that are widely recommended are Code Complete and Pragmatic Programmer. Though they cover a very wide range (everything from organizational hacks to unit testing to user design) of topics, it wouldn't hurt to check out Code Complete at the least, as it gives great tips on organizing functions and classes, modules and programs.
All these techniques and technologies are just bits and pieces you put together with your programming language. You'll likely need to learn about other tools, other languages, debuggers and linters and optimizers, the list is endless. What helps light the path ahead is finding a mentor, someone that is well steeped in the craft, and is willing to show you how they work. This is best done in person, watching someone design and code. Also spend some time reading the code of others (GitHub is a great place for this) and interacting with them on public mailing lists and IRC channels. I hang out on Hacker News to hear about the latest tools and technologies (many posts to /r/programming come from Hacker News). See if there are any local programming clubs or talks that you can join, it'd be a great forum to find yourself a mentor.
Lots of stuff here, happy to answer questions, but hope it's enough to get you started. Oh, yeah, the books, they're expensive but hopefully you can get your boss to buy them for you. It's in his/her best interest, as well as yours!
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:
> 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.
> 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.
Don't forget The Pragmatic Programmer
I can highly recommend the Artificial Intelligence for Games book mentioned in this article too, has many useful techniques written in an easy to understand manner.
Debugging is investigation. Trial-and-error is voodoo.
See "programming by coincidence" in The Pragmatic Programmer, as well as this SO post.
/u/nickjohnson has it summed up in this comment:
> Does NOBODY write unit tests?
A unit test is not a complicated thing. It takes one small, self-contained piece of code, sets up some situational context, runs the code with parameters set to interesting values, and then checks that certain conditions are met. (Conditions include things like: the correct result is returned, certain messages are sent, certain messages are not sent, the result is returned in less than X seconds, or whatever.)
It is important to note that while unit tests are not complicated, this does not mean they are not difficult to write. It is somewhere between art and science to write good unit tests, but it is possible. There is something like 20 years of work in this field, especially since the (capital A) Agile movement started. There are whole books on the subject, such as Kent Beck's effortlessly enlightening Test Driven Development: By Example.
Unfortunately, the number of programmers is growing so fast, that new programmers are joining the field faster than they can encounter experienced programmers, and so they are relearning lessons that were first learnt when they were still young, or even before they were born.
This problem didn't used to matter so much, but the situation has changed. Now that people know how to create money with code, code quality is not just a matter of late-night bug-fixing to get a small app released on time, it could potentially make or lose the entire net worth of a person, or even millions of people.
This is exactly the reason I've never bought a single ETH token. When I saw Etheruem, I said exactly this: "It seems to combine the properties of Bitcoin and OpenTransactions in the riskiest possible way". Some time later, The DAO showed the potential downside of that risk.
This kind of problem will not be fixed by developers learning how to write unit tests, it needs a bigger picture than that. But we will be able to put a lot of the world's wealth to much better use, if the developers of cryptocurrencies are able to find and reuse the learnings of software developers in other fields. And as Nick suggested, writing unit tests would be a good start.
On this topic I’d like to recommend this book:
https://www.amazon.com/Working-Effectively-Legacy-Michael-Feathers/dp/0131177052
It would be hard to evaluate yourself. It's probably best to link your Github work to someone and ask for their opinion.
PEP 8
The biggest hurdle is to accept that there's a Pythonic way of doing things.
I think a lot of people's first step to becoming Pythonic is by the way of using List Comprehensions.
Then there's generators, decorators, itertools, functools, collections, etc.
What it takes to be an Expert in Python
I'm sure his Python skill is amazing; I was too distracted by his VIM skill to pay attention.
These are language-specific things but it sounds as though you might want to get familiar with proper Software Engineering principles. Recognizing code smells and trade-offs between different Data Structures and Sorting Algorithms. You can start off with this excellent book on being pragmatic.
Pragmatic Programmer
Here are some youtube links where you can follow along and maybe even adopt their coding style. I don't remember if they are Pythonic or whatnot but I would guess that they are. They focus on projects you would have an interest in.
Sentdex
The best non-language-specific programming book I've read by far is Think Like A Programmer. It uses C for examples, but I wrote them using Python as I went through it. It teaches you problem-solving, which is all programming really is.
For beginners picking a new language, I recommend Automate The Boring Stuff for Python. Python is a great language for beginners, and this book will teach you Python and how to use it for practical tasks. The author has also made the book available for free online - though I picked up a physical copy to help support the guy. It's worth it :)
I recommend this book: Clean Code
We gave it to every new data scientist we hired at my last company.
I really enjoyed the C# Player's Guide. There's a newer version now but this is what I got.
Edit: I'm glad you guys liked this book as much as I did. To OP, I would offer two more suggestions.
as a beginner you're stuck in a position where you want to learn how to do things, but also how to write them. i.e you don't only want to paint a painting, but you also want it to be pretty and admired.
for programming there's a lot of schools of thought on this subject, some guys prefer test-driven development, others domain-driven design.
some think comments outside of method parameters are good coding praxis, others think it's a code-smell because if you have to explain your code you probably wrote it in a way that makes it difficult to understand.
some think patterns are for hipsters, others are of the correct opinion (ahem) that they are standardised solutions for common problems.
all in all, if I could go back in time 15 years when I started programming, I would read the following if they were available at the time:
https://www.amazon.com/Domain-Driven-Design-Tackling-Complexity-Software/dp/0321125215
Domain-Driven Design is the concept of breaking your code into logical real world units and bundling your code around these objects so that it makes sense to program if you understand the real world your program is mirroring. i.e if you're making a fruit shop program, you might have a fruit seller, a register, a fruit warehouse, a process to deal with ordering fruit etc.
https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
Clean code talks not so much about the architectural patterns (outside of test-driven development) but rather what's good and bad about code at it's core. i.e
if(fruitStand.Amount < 5)
{
fruitHelper(fruitStand, 3434)
}
vs
if(fruitStand.Amount < dailySoldAverage)
{
OrderNewFruit(fruitStand, wholesaleDiscountCode)
}
outside of that, I think you'll find a lot more resources by simply researching the concepts these guys talk about. programming is constantly changing, as long as you have the fundamentals in place as these guys talk about you're golden as long as you're willing to learn.
Kauf dir das Buch: https://www.amazon.de/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882 oder lass es dir zu weihnachten schenken :)
Ansonsten: Wenn du schon einigermaßen was kannst guck dich mal auf github um, da gibt es zum Teil viele Projekte wo issues für Anfänger gelistet sind bei denen man relativ einfach in ein großes Projekt findet.
Three CS fundamental books in the order I'd suggest someone read them if they don't have a background in CS.
Elements of Reusable Object-Oriented Software - "Gang of Four". My preferred way to consume this book is to read it lightly, understand the basics of the patterns, and then come back to them individually when you encounter them in the wild or think you want to employ one of them.
Then there are these books that aren't really "CS books", but are geared more twoards practitioners.
I've heard this book discussed before; perhaps you would be interested in it?
http://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
You've already done the first step: admitting that college can only teach the fundamentals while the rest of the things you need to know, you will learn while working.
With that out of the way, here's the next step: apply the Joel Test to your new employer.
If it gets an 11 or 12, you'll be fine. Find a senior developer there to mentor you and you'll be a decent software engineer in 1 - 2 years.
Otherwise, while you might learn a lot of new stuff in your first job, they might be inadequate, outdated, or outright incorrect. In this case, plan an exit strategy ASAP so that you can leave to another company that has a much higher score in the Joel Test. In this fast paced software industry, it makes no sense to spend 5 years in a company where you'd only get to grow the same amount as another guy who just spent 6 months in a better company.
Next step: read. No, not those "Teach yourself [insert language that will be deprecated in 2 years] in 24 hours" books - find the books that teach software engineering, lessons that don't get outdated. Here's the usual suggestions:
Finally, if you have free time, find a local user group or open source community and join them. Not only will you learn fundamentals like version control and automated testing, you'll also be up to date to the latest trends in the industry. Because of this, high school/college students who are active in these communities have a great advantage over their purely academic classmates, not to mention the connections they get in the industry allow them to be employed faster.
Books are still the best way to learn C++! C++ Primer, 5th Ed. covers all the basics of C++11 from functions and standard library usage to OOP and templates. Effective C++ reinforces good practices and idiomatic C++ that, despite being written for C++98, is just as relevent today as it was then, some of its contents even more so than ever before. Then Effective Modern C++ then does the same for C++11 and C++14 features, building on top of what C++ Primer covers about C++11 and introducing the subtle changes brought about by C++14. This is my primary recommendation for learning modern C++ from the ground up.
But we live in the internet age! Best make use of it! So many wonderful talks from conferences such as CppCon, C++Now, Meeting C++, ACCU and Code::Dive are all available for public viewing. With regards to modern C++, Herb Sutter's CppCon 2014 Back to the Basics! Essentials of Modern C++ Style and CppCon 2016 Leak-Freedom in C++... By Default are great videos to watch. For more specific topics, here is a list of videos that I've seen and personally found engaging, educational, and worth my time to watch (multiple times!):
rand()Considered Harmful and What C++ Programmers Need to Know about Header&lt;random&gt;for random number generation,autoanddecltype(auto)(I miss Scott :'( ).There are also shows such as CppChat and CppCast where interesting events, projects, papers, and people related to C++ are brought up and discussed. There are so many interesting blogs to read!
And there is always people on IRC (##c++, ##c++-basic, and ##c++-general) and the Cpplang Slack Channel for live updates, discussions, debates, questions, answers, and/or just plain fun with a group of people that ranges from complete noobs who are learning the basics, to committee members and library authors whose names are known across the community. If you ever have a question or need help, these are the places to go and ask (/r/cpp_questions is nice too! :P ).
And finally, links to videos, blog posts, articles, papers, interesting Stack Overflow questions, almost everything mentioned above is constantly being shared at isocpp.org and on /r/cpp. Subscribe to both to get a constant stream of links to anything and everything about C++.
Edit: as for C++17 material, the standard is not technically completed/published yet, but that hasn't stopped the community from creating material about it! This paper lists all the changes from C++14 to C++17, with links to relevant papers, and this Git repo provides a simple "then, and now" comparisons of the major changes to the language. Talks describing the changes in breadth and in depth have been given at conferences, and blog posts have been written for a more textual description of the changes. C++17 is not a major update like C++11 was to C++98, but full of fixes, conveniences, more language flexibility and utility, and new toys to play with! If you have a solid foundation in C++11, C++14 and in turn C++17 should be relatively easy to pick up compared to the shift from classic (C++98) to modern C++.
TL;DR Learn C++11 the best you can. Once you are comfortable with C++11, the transition to C++14 will feel natural, and C++17 will be waiting just around the corner.
Hi PizzaPartify,
I believe that different companies/teams will place emphasis on different skills. When I was helping to hire software engineers for EA's motion capture studio, I liked to see candidates who showed a strong aptitude for engineering code to be maintainable. For me, this meant a familiarity with design patterns and software development processes (like Test Driven Development or Extreme Programming). In my department, much of our code was in C++ and Python. However, other departments would use languages like Java, C# or ActionScript - depending on the project.
It would be helpful to know what role you are applying to.
To answer your specific questions:
Regardless of the language you're working in, I would also recommend Design Patterns by the gang of four (http://www.amazon.ca/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612).
A game-specific recommendation is Game Engine Architecture by Jason Gregory (http://www.amazon.ca/Game-Engine-Architecture-Jason-Gregory/dp/1568814135). It doesn't matter if you intend to write an engine or not, it is immensely helpful to understand how they work.
I own all of the Game Programming Gems books but use them more as a reference library. The books above will be more helpful right now.
I hope that helps.
If you want to pick up some Cryptography, The Code Book is a great intro.
Pragmatic Thinking and Learning is good for learning to learn.
The Pragmatic Programmer is good for project code planning and learning how to write code in a well thought out way.
Ethernet: The Definitive Guide is a good read if you want to get up to snuff on your networking, though it can be a bit dry at times.
The Pragmatic Programmer
When I know that an interview is gona be technical - I run through Expert C Programming: Deep C Secrets by van Linden. It's pretty dope - not boring and goes pretty deep on the low-level stuff.
I think this article is great. Writing good maintainable code is a must for those that want to advance with their career. I'd suggest Clean Code to those that want to get better at this. Note that this is not a fun book, the first chapter even goes into detail saying how it's going to be a slog to get through. Other things to do are submit code for regular review, try and work with others as much as possible since it will make you much better at programming, and take your time doing things the right way, rather than the fast way. Speed comes later.
There's a book called Clean Code that may interest you. I have it and still need to read through it, but it's been recommended countless times on here.
I'd go read books about the A+ cert (you don't need to certify but it's great material).
For other technical things I recommend a lot of books that are amazing:
Use technology books to learn processes, not end results. To be a better IT person, you should know how computers work as a system, not how to do say "Map network Drive in Windows", learn how those drives are mapped, what are the underlying fundamentals?
Clean Code is a great resource that touches on this topic and several other coding conventions.
http://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
Uncle Bob (the author of Clean Code) recommends that you organize your methods based on the context and the level of clarity. He would suggest putting the high level code near the top with the smaller helper methods near the bottom.
It compares a class to a newspaper. In a newpaper, you generally have the Subject at the top, with a high level description of the events that have taken place. As you read down the page, the articles will change from high level descriptions to low level details of the events.
Obviously, there are sometimes exceptions to this suggested rule.
TLDR: I wouldn't organize methods alphabetically. I would organize them logically from high level to low level.
I'm available for $140/hr. ;)
Honestly, there is more than one right way, and it depends on your particular architecture. However, there are a few obvious ones, and I apologize if I'm insulting your intelligence:
From there, it's details.
http://www.amazon.com/Continuous-Delivery-Deployment-Automation-Addison-Wesley/dp/0321601912 is a bit repetitive, but it is "the book" for figuring out the right way.
As for the time to implement it, it's a bit of a virtuous cycle. The more you automate, the more you have time to automate.
It seems as though you're focused on a particular method for your deployment strategy right now and it may be useful to take a step back and see if your requirements have already been met by recommended patterns.
What you're describing in the above is an integration workflow, and there are many well tested strategies already out there for integrating code (depending on your language/framework, this work may already have been done for you). Most importantly, these strategies rarely suggest cyclical actions like your FTP^(*) transfer from html back to "Remote1".
Ideally, you want your flow to look something like the following:
git repository -&gt; integration steps -&gt; build -&gt; build artifacts -&gt; artifact repository -&gt; deployment tool -&gt; deployed codeNote how this is a unidirectional flow, with nothing being pushed back into the Git repo. You may need to pull artifacts in from multiple build pipelines depending upon your requirements, but if you see the flow being reversed (committing back to git), you should carefully consider why you're doing so and ensure that there's not a better solution^(†). Additionally, while you may very well not need some of the previously listed steps, you should understand what each of them is and make an informed decision about whether or not it should be included.
I would strongly recommend spending some time diving in to Continuous Integration and Continuous Delivery/Deployment (CI/CD) and the patterns used within those methodologies, keeping in mind that CI/CD does not start with automation, but with understanding your code and requirements. One book I would strongly suggest is Continuous Delivery by Jez Humble and David Farley (https://www.amazon.com/Continuous-Delivery-Deployment-Automation-Addison-Wesley/dp/0321601912). It's starting to show its age a bit, but the fundamental ideas are still there and there's a lot of value to be gained from reading it.
Focus your reading on the what and the why before you move on to the how. There are tons of articles out there on how to build fast and efficient CI/CD pipelines, but if you don't have a solid understanding of why the pipeline should be there in the first place and what value it adds, it's easy to see articles of this nature as pointless exercises or end up building something that doesn't really fit your requirements.
&#x200B;
* This is a warning sign, by the way. If you find yourself thinking that FTP is the solution, consider it a red flag; step back and re-evaluate.
† There are some common patterns which result in committing code back to a git repository, but they solve rare use cases and tend to generate a significant amount of debate. In particular, some say that generated code should be committed back to a repository. As an alternative, I would suggest considering generated code to be a build artifact and storing either it or resulting binaries in an artifact repository rather than trying to commit back to git.
/me suggests reading Working effectively with legacy code which helps by providing more tools for proactive handling of "legacy issues".
In Michael Feather's Working Effectively With Legacy Code, he recommends a technique of refactoring for understanding. Clean up the code as you try to understand it, extracting methods, renaming variables, etc. You don't have to commit the changes, but the act of refactoring might just foster better understanding.
Check out the book Think Like A Programmer by V. Anton Spraul. Although he uses C++ for his examples, his principles on problem solving can be related through any language. As mentioned, Code Wars is a great place to go for practicing what you covered in the book.
If you want to get an idea of what is covered in the "Think Like a Programmer" book, the author has a Youtube Channel and Playlist with tutorials on some of the practices in his book. This book along with Code Wars helped get over that hump from just understanding to practical application.
Edit for Errors in linkage.
I have been doing these challenges
And also using this book to get better at coding, in general: Here you go
Both links are C++ related and work on challenges which build on each other.
This book: https://www.amazon.com.au/Clean-Code-Robert-C-Martin/dp/0132350882.
It helped me not to feel bad when I couldn't understand somebody else's code, since it could very well be designed poorly (I was struggling for weeks at work trying to rewrite a program, my mental leap occurred when I realised I was looking at spaghetti code all along). And that coding is like an art form, it communicates an idea to the reader.
I think it would be good for you to read Clean Code. The things you dismiss as unimportant are in reality super important to make for a codebase that lasts longer than a couple of months.
Good, accessible code does not contain spelling errors. A 500-line class is too long. At my work, even things like
//This method does xusually get a comment saying "missing space between after//".Yesterday, we merged in a PR that had been open for 2 days and had 76 comments on it (that, admittedly, was too much, but it goes to show that the details matter, even in large PRs). Reviewing again after incorporating code review feedback is just as important because it's brand new code that others will have to approve.
Also agree with /u/batsam that we try to keep our PRs small so it makes it easy to review.
https://www.amazon.com/Test-Driven-Development-Kent-Beck/dp/0321146530
You've got a lot of foundational knowledge to pick up if you're going to successfully complete this. And fair warning: for people with excellent domain knowledge, the task ahead of you can take months. My suggestion would be to read the following resources, to figure out what extra knowledge you need from there.
Jez's book on Continuous Delivery - http://www.amazon.com/gp/product/0321601912/
Paper on CI with Docker - https://www.docker.com/sites/default/files/UseCase/RA_CI%20with%20Docker_08.25.2015.pdf
Pattern of CD with New Relic - https://blog.newrelic.com/2015/03/06/blazemeter-continuous-delivery/
CI/CD in the web development space - https://css-tricks.com/continuous-integration-continuous-deployment/
Do you already know how to program?
If not, then read Structure and Interpretation of Computer Programs.
If yes, then get C++ Primer by Lippman.
The newest edition of C++ Primer also covers C++11. I'd recommend reading that before reading TCPPPL. See http://www.amazon.com/Primer-5th-Stanley-B-Lippman/dp/0321714113
I would supplement your class with one of the many great C++ books out there, because there are many ways to learn C++ but few of them are good (or even "right") ways.
You should be careful to distinguish between best practices from C++ and the new ones in C++11, and I've found that many courses tend to teach C++ as if it's just C with some extra features.
Of note, some really good books are:
At least as good starting points on the "new" C++, and I'm sure others have some really great suggestions too.
Read this book, young wizard.
http://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882/ref=sr_1_1?ie=UTF8&amp;qid=1459206137&amp;sr=8-1&amp;keywords=clean+code
If upgrading your application from Yii1 to Yii2 requires a rewrite, then switching to Laravel or Symfony will also require a rewrite.
If you have read Clean Code: A Handbook of Agile Software Craftsmanship by Robert C. Martin, then you might remember the Grand Redesign in the Sky - if not, take a look at What is Clean Code?:
> The Grand Redesign in the Sky
>
>Eventually the team rebels. They inform management that they cannot continue to develop in this odious code base. They demand a redesign. Management does not want to expend the resources on a whole new redesign of the project, but they cannot deny that productivity is terrible. Eventually they bend to the demands of the developers and authorize the grand redesign in the sky.
>
>A new tiger team is selected. Everyone wants to be on this team because it's a green-field project. They get to start over and create something truly beautiful. But only the best and brightest are chosen for the tiger team. Everyone else must continue to maintain the current system.
>
>Now the two teams are in a race. The tiger team must build a new system that does everything that the old system does. Not only that, they have to keep up with the changes that are continuously being made to the old system. Management will not replace the old system until the new system can do everything that the old system does.
>
>This race can go on for a very long time. I've seen it take 10 years. And by the time it's done, the original members of the tiger team are long gone, and the current members are demanding that the new system be redesigned because it's such a mess.
>
>If you have experienced even one small part of the story I just told, then you already know that spending time keeping your code clean is not just cost effective; it's a matter of professional survival.
Unless you and the team you work with has already asked and answered these questions, maybe there are more interesting questions to ask, for example:
> My code works, but if I was in a professional team, would they allow 5 nested if statements?
Probably not. I can strongly recommend reading the Clean Code book, it deals with a ton of these kinds of questions. And not just read it; apply what you read too.
IMHO,
step 1: Read https://www.amazon.com/Pragmatic-Programmer-20th-Anniversary-2nd/dp/0135957052/ref=dp_ob_title_bk
step 2: Read https://realpython.com/python-pep8/ and https://docs.python-guide.org/dev/virtualenvs/
step 3: Write a REST API which takes arguments from the URL, uses these arguments to run some predictive model of your creation, and then returns the result; since you already know Python, I'd recommend using Flask, there are many free tutorials, just google it. If using Python, I highly recommend using PyCharm (the free community edition is enough) over Jupyter or Anaconda, the latter will let you do many bad things which would trigger a red warning in PyCharm (such us doing import in the middle of the file).
step 4 (optional, but recommended): Learn the basics of Java (this tutorial should be more than enough https://www.tutorialspoint.com/java/index.htm ) and read https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
step 5: Write a publisher application which reads a csv, xml, or json file from disk (for bonus points: from someone else's public REST API for data, for example https://developer.walmartlabs.com/docs/read/Search_API ), and turns the data contained within into a list of python dictionaries or serializable objects (btw, read up on serializing, it's important), and then sends the results into a kafka or rabbitMQ queue. I would strongly recommend sending each item/record as a separate queue message instead of sending them all as one huge message.
step 6: Learn how to use cron (for bonus points: Airflow) to make the application from step 5 automatically run every second day at 8 am
step 7: read the closest thing in existence to being the data engineering book: https://dataintensive.net/
step 8: Write a consumer application which runs 24/7 awaiting for something to appear in the queue, and when it does, it calls your rest api from step 2 using the data received from the queue, adds the returned result (predicted price, or whatever) to the data, then runs some validation / cleaning on the data, and saves it in some database (SQLite is the easiest to have running on your local computer) using an ORM (such as SQLalchemy).
step 9: Add error handling - your applications should not crash if they encounter a data-related exception (TypeError, IndexError, etc.) but instead write it to a log file (as a minimum, print it to the console) and continue running. External problems (connection to the database, for example) should trigger a retry - sleep(1) - retry cycle, and after let's say 5 retries if it's still dead, only then the application should crash.
step 10: For bonus points, add process monitoring - every time your application processes a piece of data, record what category it was in a timeseries database, such as influxdb. Install grafana and connect it to inlfuxdb to make a pretty real-time dashboard of your system in action. Whenever your application encounters a problem, record that in influxdb as well. Set grafana to send you an email alert whenever it records more than 10 errors in a minute.
Step 11: More bonus points, add caching to your application from step 2, preferably in Redis (there are libraries with helpful decorators for that, e.g. https://pythonhosted.org/Flask-Cache/ )
I'm assuming you are familiar with Spark, if not, then add that to your learning list. A recommended intro project would be to run some aggregation on a big dataset and record the results into a dedicated database table allowing for fast and easy lookup (typical batch computing task). You could also rewrite the applications from points 5 and/or 8 to use spark streaming.
I also heavily recommend learning how to use docker and kubernetes (minikube for local development), this is not only super useful professionally, but also makes it much easier to do stuff such as running spark and airflow on your home computer - downloading and running docker images is way easier than installing any of those from scratch the traditional way.
One crucial advice I can give is the mindset difference between data science and data engineering - unlike in data science, in data engineering you normally want to divide the process into as small units as possible - the ideal is to be processing just one [document / record / whatever word is appropriate to describe an atomic unit of your data] at a time. You of course process thousands of them per second, but each should be a separate full "cycle" of the system. This minimizes the impact of any crashes/problems and maximizes easy scalability¹. That is of course assuming that the aim is to do some sort of ETL, if you are running batch aggregations then that is of course not atomic.
¹ As an example, if your application from step 5 loaded all the data as one queue message, then the step 8 application would have to process it all in some giant loop, so to parallelize it you would have to get into multi-threaded programming, and trust me - you don't want that if you can avoid it (a great humorous tale on the topic http://thecodelesscode.com/case/121 ). You also have to run it all under one process, so you can't easily spread across multiple machines, and there is a risk that one error will crash the whole thing. If on the other hand you divide the data into the tiniest possible batches - just one item per message, then it's a breeze to scale it - all you need to do is to run more copies of the exact same application consuming from the same queue (queue systems support this use case very well, don't worry). Want to use all 8 CPU cores? Just run 8 instances of the consumer application. Have 3 machines sitting idle that you could use? Run a few instances of the application on each, no problem. Want the results really fast? Use serverless to run as many instances of your app as you have chunks of data and thus complete the job in an instant. One record unexpectedly had a string "it's secret!" in a float-only field and it made your app crash? No problem, you only lost that one record, the rest of your data is safe. Then you can sit back and watch your application work just fine while the colleague who decided to use multi-threading for his part is on his fifth day of overtime trying to debug it.
You were showing off. I probably would have hung up as well.
The best code is boring. It just reads like prose. And it's tremendously difficult to write.
I am an architect / dev lead. I read a lot of code that others wrote. I don't want to spend any brain cycles parsing your code; I need to be able to focus on what you are doing and what the overall design is.
We have one developer here who apparently gets a bonus every time he uses the ternary operator. He likes to nest them as well as AND and OR his conditions.
return cond1 && cond2 ? val1 : !cond1 && cond3 || cond2 ? val2 : val 3
Very cute, but utterly unreadable.
My advice to you is to read the following books:
http://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882/ref=la_B000APG87E_1_1?s=books&amp;ie=UTF8&amp;qid=1395528501&amp;sr=1-1
You should read Clean Code.
The second edition is due in June http://www.amazon.com/Programming-Principles-Practice-Using-Edition/dp/0321992784/ref=sr_1_2?ie=UTF8&amp;qid=1398086459&amp;sr=8-2&amp;keywords=programming+principles+and+practice+using+c%2B%2B
Enter Bjarne Stroustrup! https://www.amazon.co.uk/Programming-Principles-Practice-Using-C/dp/0321992784/ref=dp_ob_title_bk
Learn C++ (the language you need for Unreal Engine) from its creator. Very beginner-friendly too. "The book is primarily designed for people who have never programmed before".
Or you can follow this book instead.
Ok, let's see. A few quick points:
Rooted in in standard, everyday mathematical notation? public static final volatile interface abstract class transient inner class inner anonymous class objects values boxed values..... etc...
Java Generics has drawn heavily from the functional programming camp which is based on lambda calculus. See google tech talk: Faith, Evolution, and Programming Languages
Extremely easy to read and understand? Go read Java Puzzlers and Effective Java to see how many easy mistakes you can make.
Static types enables blablabla...? Not possible without static typing...? Does he realize that tools like Eclipse grew out of a smalltalk project and that smalltalk pioneered automatic refactoring ages ago? Smalltalk is one of the most dynamic language around, and it's more than 30 years old.
Most bugs are found at development time with java? That's not my experience :-)
Simple puzzle: for which values for someInt does this code fail?
int myPositiveInt = Math.abs(someInt);
assert myPositiveInt >= 0;
Intermediate-Pro
Effective Java, 2nd Edition
Not game-specific, but these books are definitely industry essential books when it comes to anything related to software development.
In no particular order (though Code Complete should probably be first):
Code Complete and Pragmatic Programmer are great books about programming as a craft and are both language agnostic.
Strictly in order.
Head First Programming
Head First Java
Effective Java
Head First Design Patterns
Head First Software Development
<http://developer.android.com/training/index.html&gt;
You are welcome!
Today they are saying the problem was actually a virtual function not being overloaded properly.
> Long story short, diffing the 1.1 and 1.2 executables after seeing all the bug reports to see if I could fix any of them. There's a MagicTarget interface class that is implemented by everything you can damage. One of the virtual functions on that class is used to calculate resistance (as a scale factor), and the diff showed that for the versions used by Actor (base class for Character/PlayerCharacter) it had fallen back to the base class' implementation of "return 1" instead of the larger function before. A new virtual function with roughly the same code as the old MagicTarget function appeared on Actor, but it isn't being called. It seems like someone accidentally misnamed or changed the signature of that function in Actor (or vice versa), so it isn't overriding the function in the interface.
http://forums.bethsoft.com/index.php?/topic/1288179-wipz-skyrim-script-extender-skse/page__view__findpost__p__19568346
Bethesda doesn't even have an automated unit testing system to make sure their virtual function calls are hitting the proper targets. Simply unbelievable for a project as large as a huge open world AAA game that probably has like 5 million lines of code. I suggest we all send Bethesda this book for Christmas: http://www.amazon.com/Growing-Object-Oriented-Software-Guided-Tests/dp/0321503627/ref=sr_1_3?ie=UTF8&amp;qid=1322766398&amp;sr=8-3
I don't think Laravel is the right direction to be going, honestly. Laravel is great for starting new projects, but it isn't so great if you want it to be just a small part of a larger site.
I suggest you check out the following two books:
Working Effectively with Legacy Code
Modernizing Legacy Applications In PHP
I've read the first one, and can definitely recommend it. The second I haven't read, but it sounds like it may actually be more appropriate to your actual situation, since the first book often assumed that your starting code base is better than what you seem to have.
I'm just two months into my first real job for programming and have a few books I've been going through.
Clean Code is a book not just about writing code, but good code that is easily maintained and passed down to other people to understand.
Working Effectively with Legacy Code was a great read coming into company that has been around for 20 years and is on the third iteration of their product.
I am doing web development so You don't know JS, Javascript: the good parts and then Javascript The Definitive Guide have all been a great help.
If you aren't much a book person, Pluralsight.com is awesome for info on tons of different technologies and is well worth the monthly cost. Go follow every major name in your preferred technologies on twitter. They will tweet all sorts of cool things to learn about. Also, PODCASTS!!!. I don't even listen to music anymore. If I'm in the car alone I'll be listening to Dot Net Rocks or Javascript Jabber.
Lastly, there are subreddits for every tech imaginable. Go subscribe to them and hit everyone up for where they get all their info!
> So something that would take in excess of 3 years to master is out, if you catch my drift.
You seem to be misguided on this point - while you can pick up the basics/fundamentals of programming pretty quickly, if you're so inclined, the actual practice of writing software, and writing it well, is going to take a lot of time investment. I look back at code/software I wrote when I was just starting out professionally, and while they worked, I know how poorly they compare to what I can write/design now.
Having 3 years of software development experience when starting from zero would probably leave you at 'junior' or 'mid' level at the end, and if you don't have a more experienced developer mentoring you throughout the process, you may be at a disadvantage. From the sound of it, your school has no actual programmers/developers.
With that said:
Clean Code
vs
Code Complete
In my experience, most physicists write spaghetti code with no documentation that is a nightmare for others to work with, and even the original author of the code after not looking at it for a while.
While I don't think my code is that bad, I do think that I could have structured it to have fewer global variables by making better use of functions.
Here is a few quick tips for jupyter notebooks specifically. Here is a book on writing clean code. I would also recommend reading the python style guide (pep8 and pep257). I'd also highly recommend learning how to use a linter such as pycodestyle or pylint.
Clean Code: A Handbook of Agile Software Craftsmanship it explains how to write elegant code in a simple and clear manner
http://www.amazon.com/dp/0321714113/ C++ Primer is what I bought and I found it very useful. It covers all the c++11 stuff
Presumably it's an affiliate link https://www.amazon.com/Computer-Programming-Volumes-1-4A-Boxed/dp/0321751043/ ~$180
I don't think it's reasonable to speak about "canon" books in computer science - the field has become so broad that a handful of PhDs in the modern era could get to the very bleeding edge of their niche and not share any crucial books in common among their libraries.
That said, here are a few I think are fantastic:
Among these, I think Stevens' UNPv1 is about the best textbook, by a lot, I've ever owned.
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!
Clean code... you can find it on amazon or anywhere else. Pretty highly regarded.
Edit: http://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
Automate the Boring Stuff with Python
There isn't a way to learn to code faster, the best thing you can do is code every day. And I mean EVERY day. IMO Python will open the most doors. you may need to pick up other things along the way but Python is a good base.
---
ABC
Always
Be
Coding
I picked up Accelerated C++ and it's, by far, one of the best books I've read. It's terse and provides an amazing amount of detail for its size.
Amazon
If good is the priority, I recommend going straight to the source -- the guy who invented the language, Bjarne Stroustrup. You can buy it new for $35, or head to your local library and borrow it for free.
ovde je neces naci, tako da bih ti preporucio amazon. obavezno uzmi 2nd edition posto sadrzi najnovije standarde (c++11 i c++14).
kada uzimas knjigu sa neta, proveri bookdepository.com i amazon.com i vidi koja je jeftinija. ako su iste/priblizne cene, uzmi sa bookdepository posto isporucuju mnogo brze od amazona.
Colt Steele's web developer bootcamp on Udemy is a great one! You can get it for $10 currently, sale is for 2 days only though. It honestly depends on your price range and if he wants something physical like a book, or a course. If a book, is a good one there's plenty other ones too.
Again, it depends on the price range ultimately.
Here is my list if you need to become a good programmer with Python as your language of choice.
Follow this order for rigorous course on learning Python thoroughly.
By the end, you will be famished but you will have a very solid base to understand and design code for complex systems. To get more hands on experience, start with any popular open source project and delve into the source code. Don't start with the master branch of the codebase, start the version 1 tag of the codebase and progress through the next version tags and check for changelog and move on.
E.g mitsuhiko/flask
Finally you will have a solid understanding of Python as well as how objects communicate behaviors.
Scott Meyers Effective C++
Or you could get the 3rd edition:
http://www.amazon.com/Effective-Specific-Improve-Programs-Designs/dp/0321334876/
with 5 more ways to improve your C++
Hi! I recommend the following books:
You can find other similar books here and here.
One that I especially liked (although closer to an algorithms textbook, but also had very cool "War Stories") is called The Algorithm Design Manual.
Have fun reading! :D
Android is java, there is 100 million devices right there.
I know Java, along with a handful of other languages used on the JVM (kotlin, scala). I also use Python quite a bit, C++/ObjC (though I use it much less), and I dabble in JS if needed. I've written perl, php, pascal just to new a few others. Once you learn the fundamentals of CS, you should be able to grasp any C like language pretty quickly. (even C++ if you just keep it simple)
What you should focus on is learning object orientation. Relationships between different objects/classes, their interfaces, and how to actually construct software. Don't worry about language so much yet, you will quickly get the point where you know 5+ languages.
Now go read this book.
https://www.amazon.com/Pragmatic-Programmer-Journeyman-Master/dp/020161622X
Also, I have to say that knowing Java and Python is a sought after combination.
I think the book people normally recommend for this is Effective Java by Joshua Bloch
> But I've come to avoid mocking as much as possible as tests based
> on mocks don't prove anything, except that my code works under
> the assumptions i made
This isn't really how mocking is supposed to be done. I would recommend reading Growing Object Oriented Software Guided By Tests, written by the authors of JMock, and the people who originally came up mocking as a test practice.
In short, you don't mock external services or anything you don't own. You should mock an interface you created and that you own, that defines the contract that external dependencies must meet to work with your class on your terms (aka, ports and adapters). This is the essence of dependency inversion. Mocks ideally guide development towards DI.
The adapter is concerned with making sure that the external dependency actually conforms to the contract defined by the interface that is mocked, and adapter code must definitely be integration tested. And the integration test now needs only to verify that the adapter meets the terms of the contract. This separates testing the logic of the system (where TDD fits in) from tests of the integration with the external environment (functional and integration tests). However, the authors of the GOOS book recommend writing the user acceptance tests (functional tests) before you write the unit tests (which they lump into TDD, in a more holistic sense).
Sounds like a good case to harness this legacy codebase in a unit test framework.
See Working Effectively with Legacy Code.
Here's a book recommendation: Working Effectively with Legacy Code
I think Working Effectively with Legacy Code is the classical book on the subject. My personal recommendation is to write a test for every piece of code you read. It doesn't have to be a perfect test, but giving yourself something that will keep your understanding tied to the code and which you can pdb through if you lose understanding will be really helpful. At a certain point, you have to say screw the side-effects and construct a large numpy array and pass that in, create some files in weird places, or inline some text to make it work. Take the time to do things the right way and they'll go faster.
Smalltalk Best Practice Patterns by Kent Beck. In my opinion, it's his best book. It's a great book on the nitty gritty of coding.. great for all programmers. It's easy to read even if you're not a Smalltalker; all you have to do is google for a Smalltalk cheatsheet.
I also like Working Effectively with Legacy Code. It's about the sort of code that most of us confront daily: how to deal with its problems, and get it under test so that you can refactor it or add to it without gumming it up.
You only need one book: The C Programming Language, 2nd Edition.
However, I would also recommend you own C: A Reference Manual, Fifth Edition, especially for the C99 coverage. Not needed immediately, by any means, but well worth having - the reference section of K&R will serve you well for quite a while for any C89/C90 coding.
A fine supplemental book is C Programming FAQs. Much of it is available online as the comp.lang.c Frequently Asked Questions, but the book adds material and polish.
Once you're ready for advanced C knowledge (I'd guess after at least a year of substantial C programming, but only you know when you're ready and interested enough), you really want to read Expert C Programming: Deep C Secrets, by Peter van der Linden.
There are some other very good books that have more or less direct applicability to C programming. The two I would call out are The Practice of Programming and Programming Pearls. Both worth far in excess of the asking price.
Good luck, and welcome to the deep end of the pool. The water's fine.
K & R and Expert c programming are the best books I have read on programming. http://www.amazon.com/Expert-Programming-Peter-van-Linden/dp/0131774298
If you fully understand c then you will better understand how computers work and be able to debug issues in other languages where details are hidden in the language libraries and syntax
Depends on what language or area you want to specialize in.
But the basics are important. Not so much being able to solve those stupid white board tests (I would not shoot for a company that does those as a self-taught first job individual. You'll just be discouraged. I've got 6 years experience and I doubt I could pass those stupid test without extensive studying.)
It's hard to say, b/c of some of it is...just exposure and your ability to think about abstract problems. I'm honestly not sure how to word it. But people who have had to go through academic training. EG Algorithms, data structures, modeling, etc... seem to just have a better understanding of abstract processes (if that makes sense).
Some things I feel are personally important.
Clean Code: https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882/ref=sr_1_2?keywords=clean+code&qid=1563404400&s=gateway&sr=8-2 Believe this is the one. I've never read it page by page but we had one college professor who basically taught the concepts from it.
Ability to actually talk about what it is you've done and know. The best way to do this is to have actually tackled a complex problem or project. Even if you need to make one up, you'll learn a lot. Things like properly structuring objects. Data flow. Singletons. Data storage. Security (if you're doing something web based). I personally built an entire website from the ground up. It included a content management system for the homepage. Custom permissions and a forum's section. I learned more from that personal project than I have from work honestly. It's now trashed in Github somewhere, but that wasn't the point.
Abstraction abstraction abstraction. This kind of goes with the clean code point.
Knowing the importance of testing. Difference between unit and e2e (if you're doing web). Some companies don't even write test so your mileage may vary on this one. Usually they still pretend like they do in the application and interview. But once you get in, they'll have zero test. And this isn't the worst if the application isn't very large or complex. There's a lot more to test but unless you're applying for that kind of position, it may not be as important. But being able to talk to some of the basics is good. (Like knowing some terminology. Black box testing, smoke testing, uhh, drawing blank on the others...you can tell what jobs I've had sigh...)
I would say the tl;dr is...actually make something. And not something simple. And do it right. This will give you a lot of things to learn and think about and discuss in an interview. It'll make you more engaged and willing to learn. And most importantly, it'll demonstrate you can actually do what you say you can.
Continuous Delivery by Jez Humble and David Farley is excellent:
http://www.amazon.com/Continuous-Delivery-Deployment-Automation-Addison-Wesley/dp/0321601912/ref=sr_1_1?ie=UTF8&amp;qid=1426364547&amp;sr=8-1&amp;keywords=continuous+delivery
If you already know the basics of programming, then the C++ Primer is also an excellent introduction. The 5th edition is updated to include C++11.
I've been personally learning C++ from this book and it's really good. The only problem is that it talks only about C++11 and not 14 and 17 versions, but these new versions are relatively minor compared to C++11 and there's no better and more comprehensive book that talks about the most modern versions...
Well, there's the classic, Clean Code, which I haven't read but have seen recommended as a great book on this topic. But, in my opinion, as with anything else in programming, you get better by doing, and that includes writing better code. The more code you write the more you'll see basic patterns crop up and you'll start to realize what does and doesn't work. Does inheritance make sense here or should I use some type of composition. Is it worth refactoring this piece of code out to a more general abstraction. When I write, I try to have the mindset that someone else will be using my code in the future and I should write my code in a way that is as accessible for them as possible.
Clean Code http://amzn.com/0132350882
Code Complete 2 http://amzn.com/0735619670
Both are great books. I just finished reading Clean Code and I highly recommend it.
No, it would be better to just raise the point in the next stand up meeting, perhaps get a senior dev to sit with you while you figure out why the crap was written originally (Was it just a short cut?), whether it's needed any more or whether it should be re-written properly.
Once that decision has been made, the code and the horrendous comment can be removed or replaced by a more suitable solution.
We live in a modern age of modern source control, we do not need to leave messy large comment blocks all over our code.
I recommend the book 'Clean Code' http://www.amazon.co.uk/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
Learn some design patterns: http://gameprogrammingpatterns.com/
Follow the SOLID principles: https://en.wikipedia.org/wiki/SOLID_(object-oriented_design)
Read "Clean Code" (and everything else by Robert C. Martin): http://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
> 5 - I've always struggled with this, anyone i talk to says comment your code, i just never see the use for me. ITs something im working on.
Clean Code: A Handbook of Agile Software Craftsmanship
Read that book, and start applying the techniques as you finish each chapter.
The agile principles are based around the idea of iterative development. This invites what you're calling rework to make the product the best it can be.
Obviously, you're coming at this from a place of frustration because you want to meet deadlines but the "simple" solution is to build all these steps into your estimates. If you're not setting the deadlines, then you need to be up front with your manager about what you can get done in the given time. Maybe it'll work, but not be clean code (the P.S. here is that after it ships, you need time to make it clean). Maybe you can get features X and Y done, but not Z.
Refactoring and code reviews are part of the job. Yes, your manager is going to make suggestions you might not agree with and, yes, the senior devs are going to send you back to the drawing board sometimes. Sometimes it's because they're jerks and sometimes it's because experience has taught them something.
All in all, I'd recommend reading any of the following by Robert Martin. Clean Coder is perhaps most relevant to estimates and deadlines but they're all really helpful.
Clean code. read it learn it love it
Uhm, I would first start with a complete introduction to OOP. This book:
http://www.amazon.co.uk/Thinking-Java-Bruce-Eckel/dp/0131872486/ref=sr_1_1?ie=UTF8&amp;qid=1451750882&amp;sr=8-1&amp;keywords=thinking+in+java
helped me a lot. Once you go through with it, you should have a pretty solid understanding of OOP and Java.
Also I cannot stress enough how important this thing is, many people seem to neglect it nowadays:
http://www.oracle.com/technetwork/java/codeconventions-150003.pdf
I recommend following books once you understand Java more :):
Effective Java by Joshua Bloch:
http://www.amazon.co.uk/Effective-Java-Second-Joshua-Bloch/dp/0321356683/ref=sr_1_1?ie=UTF8&amp;qid=1451750978&amp;sr=8-1&amp;keywords=effective+java
Head First - Design Patterns by Eric Freeman:
http://www.amazon.co.uk/Head-First-Design-Patterns-Freeman/dp/0596007124/ref=pd_sim_14_2?ie=UTF8&amp;dpID=61APhXCksuL&amp;dpSrc=sims&amp;preST=_AC_UL160_SR138%2C160_&amp;refRID=1J4FWDFZDD8XERKQEY2Q
Clean Code by Robert C. Martin:
http://www.amazon.co.uk/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882/ref=pd_sim_14_3?ie=UTF8&amp;dpID=51oXyW8WQwL&amp;dpSrc=sims&amp;preST=_AC_UL160_SR124%2C160_&amp;refRID=1J4FWDFZDD8XERKQEY2Q
Since you're already a programmer: Effective Java, 2nd Edition. That's pretty much your definitive Java language and Java best practices reference.
I would not recommend the Head First series - those are more geared to novice programmers. I don't think you'll have much trouble picking up basic object oriented concepts, which is probably the only thing that book might help you with.
For general programming reading, I recommend The Pragmatic Programmer - great read, lots of excellent advice in there.
I was right where you are now about 6 months ago. I'd done some unit tests in previous projects and could kinda see the point in using them for certain things, but I didn't understand the need for writing tests first, and didn't understand the value in the red, green refactor cycle.
I can tell you six months ago I started working for a company that believes heavily in TDD, and after going through the initial pain barrier, I now can't see any other sane way of writing code.
There were a few hoops I had to leap through in order to get to this point. One of them was due to the fact that I simply wasn't testing things correctly in the past. You should always isolate your tests to the EXACT thing you are testing in each case - so you should never really be connecting to the database, or depending on other modules etc. Any dependencies therefore need to be injected into the system under test and mocked accordingly, so you know you are isolating the thing you want to test.
You also should never be testing implementations, which is why you should never have to test private methods. You only care that the public methods of a class will return whatever you expect under the conditions you are testing for. This is crucial, because it's this that makes it really easy to refactor your code later.
When you take this approach for everything you do (combined with doing red, green, refactor), you find yourself soon entering a luxorious position of being able to refactor things at a higher level just to make things cleaner and easier to understand.
Just this week I took a system with over 2500 unit tests and refactored some of the fundamentals of that system - found some abstractions and moved them higher up the chain + extracted some interfaces to make the code easier to extend without modification, and all the while I knew everything was working because my unit tests proved it. This is part of the core of a system that deals with literally millions of users each day (seriously), and I did so without fear.
This approach means the code is constantly getting cleaned and tidied up as we go along.
The red/green/refactor approach works something like this:
The refactor step is crucial, but because your tests should be rapid (because we've mocked out all dependencies), you can refactor in very small steps and run the tests each time you make a small change. This way you can neaten up and tidy your code in small, safe, incremental steps, and you keep doing so until you are happy that it's easy to understand and give you the flexibility you need. Once you're happy, you move onto the next test.
The entire cycle is quite quick actually - much of the complexity comes down to to learning the best way to test and how to mock out dependencies etc.
Our suite of around 2500 tests takes about 15 seconds to run, but as I'm working on a feature I may only be running one test at that point, so it'll usually take less than a second to run the tests as I'm refactoring. Toward the end of the process I run the entire test suite to make sure everything still passes.
I went from not believing to seeing this work in practice, and now I honestly don't think I can work anywhere that doesn't do TDD. I would be happy to teach other people how to do it in a company, but as mad as it sounds, to me now, not doing TDD is like saying you don't want to use version control. This has all changed in the last 6 months, having seen it work in practice.
Here's a book I highly recommend: http://www.amazon.co.uk/Growing-Object-Oriented-Software-Guided-Signature/dp/0321503627
I love the title of that book "Growing Object Oriented Software Guided By Tests" - this it the thing - working this way allows you to "grow" your software, and the tests really do guide you towards the solution you actually need (this is powered by the refactor step).
Read 'Continuous Delivery', 'The DevOps handbook', and perhaps 'Accelerate'.
For the first two I think OP means:
https://www.amazon.com/Design-Patterns-Object-Oriented-Addison-Wesley-Professional-ebook/dp/B000SEIBB8
https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
I'd also recommend:
https://www.amazon.com/Clean-Coder-Conduct-Professional-Programmers/dp/0137081073
https://www.amazon.com/Pragmatic-Programmer-Journeyman-Master-dp-020161622X/dp/020161622X
Pragmatic Programmer is over a decade old, but I doubt you'll more useful advice.
I agree that Code Complete is an excellent book. Another I'd add to the list is The Pragmatic Programmer.
Effective Java is good but it's really about the nuances of the Java language. It looks like you are looking for better programming practices in general. If so I'd go with the books already mentioned.
Accelerated C++. Unfortunately, there isn't a C++11 update, but this really is the best way to get into C++ if you are already a programmer.
> Also, is there a cpp equivalent to lwjgl?
Dunno - what is "lwjgl"?
Introduction to Algorithms by CLRS
TAOCP is a waste of time and money; it's more for adorning your bookshelf than for actually reading. Pretty much anyone who suggests TAOCP and is less than 55 years old is just parroting Standard Wisdom™.
Godel, Escher, Bach is a nice book, but it's not as intellectually deep in today's world as it was when first published; a lot of the memes in GEB have been thoroughly absorbed into nerd culture at this point and the book should be enjoyed more as a work of art than expecting it to be particularly informative (IMO).
If you're interested in compilers, I recommend Engineering a Compiler by Cooper & Torczon. Same thing as TAOCP applies to people who suggest the Dragon Book. The Dragon Book is still good, but it focuses too much on parser generators and doesn't really cover enough of the other modern good stuff. (Yes, even the new edition.)
As far as real programming goes, K&R's The C Programming Language is still unmatched for its quality of exposition and brevity, but these days I'd strongly suggest picking up some Python or something before diving into C. And as a practical matter, I'd suggest learning some C++ from Koenig & Moo's Accelerated C++ before learning straight C.
Sipser's Introduction to the Theory of Computation is a good theory book, but I'd really suggest getting CLRS before Sipser. CLRS is way more interesting IMHO.
Basicly TDD won't help if you don't think enough about how objects are interacting. Your tests are like client code for objects you are designing. They forces you to make more easy-to-use interfaces and think more about decomposition.
I've been coding for a few years and for a while was just focused on getting things to work.&nbsp; Now I'm at a point where I know I'll figure out any given problem with my accumulated knowledge and/or additional research, and I'm noticing that not planning ahead is the most significant (lack of) action that will set me back at this stage in my practice.
&nbsp;
To remedy this, I've been looking into architectural patterns (MVC, MVP, MVVM, etc.), and UML diagramming.
&nbsp;
-----
&nbsp;
Architectural patterns were initially difficult to grasp, as many of the explanations available online dig into topics that might not make sense yet if you are inexperienced with architecture.&nbsp; The MVC Java Tutorial by Derek Banas is the best introductory explanation of architectural patterns that I've come across (he also has some great videos on design patterns & other topics).
&nbsp;
Some books that cover code structure & architecture in more detail:
&nbsp;
The author of Clean Code, Bob Martin, has a ton of talks that are a great source of info, and has also produced the CleanCoders series.
&nbsp;
-----
&nbsp;
Also check out some Software UML Examples.&nbsp; I find that mapping out an overhead view of your project before starting to code gives you a chance to make sure the majority of relationships, life-cycles, and high-level details are planned out correctly from the start.&nbsp; You'll still have to make inevitable adjustments while coding, but it's much more efficient than figuring it all out from the inside while you're building it.
&nbsp;
yEd Graph Editor is a good freeware option for creating UML diagrams.
&nbsp;
If you find that you really like the UML approach, check out Enterprise Architect.&nbsp; It's definitely worth picking up since it allows you to generate file structures from your UML diagrams, with all of the boilerplate filled out already (class/method/variable definitions, etc.).
&nbsp;
-----
&nbsp;
Also related, SourceMaking has some good wikis on:
&nbsp;
(Although their UML material is pretty in-depth and may be overkill if you just want to use UML as a quick way to plan out code.&nbsp; But it's legit if you want to go all-out UML mode)
The goldilocks zone is needing 0 comments in order to easily read your code. Chose variable names and function names which are so obvious they don't need comments. However you'll eventually need comments as well, so a simple terse comment that describes only exactly what is being done is beneficial.
When you get enough programming under your belt check out this book:
http://www.amazon.ca/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
This isn't a book per-say about system administration with python, but it is a quite useful one if you want to get into it.
https://www.amazon.com/Automate-Boring-Stuff-Python-Programming/dp/1593275994/ref=pd_lpo_sbs_14_t_2/146-3820539-3232947?_encoding=UTF8&amp;psc=1&amp;refRID=ZDZ3YRPFMWYVRR949Z70
I'm reminded of this Ira Glass quote:
https://www.goodreads.com/quotes/309485-nobody-tells-this-to-people-who-are-beginners-i-wish
Are you a professional developer? You might talk to your team lead, manager or other senior engineer on your team about making a plan to improve.
> Death by iteration or death by un-maintainability
Learn about refactoring. This is the classic book:
https://www.amazon.com/Refactoring-Improving-Design-Existing-Code/dp/0201485672
but it is a common idea now. Test-driven development could help with this.
> perfect response with a great code example way better than I could've done it given weeks or months
The key habit here is to ask yourself, "What would I have had to know to come up with this myself?" and then go learn that and internalize it so if you ever see this problem or a related one again, you can solve it. If you do this consistently, you'll have a powerful bag of tools and be able to solve lots of problems easily that you couldn't before.
Finally, it doesn't sound like you have a formal CS education. You might think of going through some undergrad CS courses online (edX, Coursera, MIT OCW, etc.) It takes long-term persistence that few have the patience for, but if you can make it through, they will transform your understanding of computers and development.
You probably already have, but if not, definitely read Design Patterns, which is old but a classic. I'd also highly recommend the Pragmatic Programmer.
EDIT: I just want to say, that I also fully support alienangel2's answer. I wanted to recommend a couple good books to get you on "the path", but ultimately, the best thing by far is to find a job that grows you. For some people, the best way to do that is to work at a super small startup, where everything you're building is from scratch. For others (like me), the best way is to work at a company with tons of really smart people who have already built great software, and learning from them and the choices they've made (and why). And if you still feel like you're regressing since school, maybe that's the answer: go back to school (i.e. get a Master's or PhD)!
u/tyggerjai is speaking the truth. Learning programming has very close similarities to learning math. You first learn the method or theory and then, through practice, learn the implementation.
There is a great book, Think Like a Programmer, in which the author tries teaching this exact skill of breaking down programming problems, which you may not know how to do, into small steps, each of which you do know how to do. Then by adding all of those steps together you get the answer you were looking for.
That, in a nutshell, is what makes for a good programmer.
I'm surprised nobody has recommended Clean Code by Robert Martin, which has good advice for keeping code clean in any language. Examples are given in Java. It echoes a lot of the advice given here, as well as explaining the reasoning behind the practices.
Simply start by writing tests for each HTTP endpoint and check the content of the response.
Maybe check out Michael Feathers' Working Effectively with Legacy Code too.
An excerpt from Working Effectively with Legacy Code by Michael Feathers:
> Unit tests run fast. If they don't, they aren't unit tests.
>
> Other kinds of tests often masquerade as unit tests. A test is not a unit test if:
>
> 1. It talks to a database.
>
> 2. It communicates across a network.
>
> 3. It touches the filesystem.
>
> 4. You have to do special things to your environment (such as editing configuration files) to run it.
>
> Tests that do these things aren't bad. Often they are worth writing, and you generally will write them in unit test harnesses. However, it is important to be able to separate them from true unit tests so that you can keep a set of tests that you can run fast whenever you make changes.
You should read Working Effectively with Legacy Code by Michael Feathers. It's a fantastic book and will help you avoid the classic mistakes.
Sounds like you need this.
Good luck!
Martin Fowler did not write Working Effectively with Legacy Code, this guy did.
If you're interested, check out Clean Code. There is a chapter on just this. Put simply, you shouldn't be afraid to add length to your variable names, so long as they can concisely describe their function. I know, easier said than done, but it's helped steer me away from using acronym and single-letter variable names.
C++ Primer is one of the usual go-to books for beginners.
[EDIT] Thank you /u/xgalaxy for pointing out I had linked the wrong one. Get this one: http://www.amazon.com/Primer-5th-Edition-Stanley-Lippman/dp/0321714113
> I'm taking a Unix class in c/c++.
Those are two very different things. Please clarify.
> We are using the book by Sobell. I want to ask if I should read the book?
Uh.. if it's required for your class, yes you should obviously read it. If you are looking for supplemental material, I'd suggest:
CSC265 should only be reserved for people who truly love math. Not for people who like math and enjoy it, but the people who sit up at night reading math textbooks for fun and doing Spivak because it feels good. I took it because I wanted to be elite at data structures. I ended up getting an offer at Google but 265 did not prepare me for interviews in the way that I thought (what I'm trying to say is my offer at Google was not because of 265).
You will be doing purely math. A lot of the topics are covered in more depth, and you have to read chapters on your own.
The questions I got were absolutely insane and had me working unbelievably hard. I'd put in almost 25-30 hours a week for the course. I was able to get 90's on the assignments (but one of them was downright impossible).
There's a lot of really smart math geniuses who take the class so if you're a "normie" or even just "smart", you will feel like an idiot. People would come to class and clearly had read way ahead, so the TA would blaze forward since you'd feel like an idiot going "no I don't get this" constantly. You'd have to spend a ton of time at home playing catch up. All my practical knowledge of data structures wasn't too useful, but attempting Faith's homework prior to doing the course helped me the most. If anything, I think reading TAOCP is probably the best preparation, but it's probably not even feasible for anyone to do that before this class because it probably takes years to properly read that.
One of the questions we got was some probability question that I literally could not get after 30 hours of trying. It was impossible for me. The answer ended up being a published paper, so you get the question then you pretty much could have published the paper if you did this question 30 years ago. When I practiced on Faith's assignments for 265, there was not a question that I found that insane to the point where I couldn't get it.
This class should only be taken IMO if you want to do algorithm research or were bored out of your mind in CSC236/CSC240. I don't know if this course is physically possible if you do it with MAT257 and 3 other courses, but I'm sure some genius would prove me wrong. There is no physical way you could do 5 courses with one of them being CSC265 and work on side projects to prepare for PEY unless you are really good.
Also it's the first class I ever took where the average was so shit for the midterm that one of the questions got turned into a bonus question right after the midterm (usually they just shift people up at the end, so doing it after a midterm tells you something).
Maybe people who did MAT157 can handle such things, I'm not sure. It was the most stressful semester I ever did. What I learned was amazing, but it will definitely fade in time because I will probably never use that knowledge since I don't intend on going to graduate school.
I'd further only recommend that class to people who are sadistic enough to enjoy such hard questions where you are literally freaking out 2 days before it's due because in 12 days you still weren't able to find the solution and kept finding holes in the problem. How I managed to get 90's on the assignment when the class average was between 65-72 is beyond me.
Lastly, this course feels much different from other courses cause the math at times isn't hard, it's just proving some discrete property tends to be nuts. However, the part I found really hard might actually be better off with people having real analysis since it was probability and real numbers which I'm not as good at.
tl;dr: If you get through it, you will be a Navy SEAL for CS. If you are asking "is the workload too much" when deciding to take this course, you should not take this course.
EDIT: I should also say if you're a CS genius then maybe the workload is normal.
Disclaimer, I have zero Ruby experience, I also suck at explaining things.
Cucumber/Aruba appear to be testing frameworks, I have no idea how they work specifically but the general gist of Test Driven Development is you write a test for what the code should do, then you write the code to pass the test (functions as specified), developers write code, run tests, release code (in short).
So assuming they are wanting this formalised by you I am guessing they want some kind of automated testing/continuous integration server. This would essentially be setting up a Jenkins server with a bunch of projects (one per code base) that uses the tests (developer written).
Example:
No CI:
You have a git repo for "project-awesome", (you'll very likely find) developers branch off of master into a feature branch, work on their stuff then merge into master when done, this will then either get packaged up or deployed from git (either manually or by a config management system).
With CI (very basic):
master is the release branch, developers branch off of a development branch do their stuff and push back to the development branch when done, from here Jenkins see the branch has new commits so runs the tests on the code automatically and if they pass merges them into master which then gets deployed, if not it'll fire off an email to whoever committed the code and give them the failed test results.
The aim here is that testing is completely automated which means even if I'm working on feature X but my changes break feature Y it will be caught (in theory) by Jenkins meaning there is a reduced risk of breaking production but pushing bad code.
I just found this page which should hopefully cover some of the general idea better than I can (and it has pictures!), personally I'm a big fan of CI and use it for everything that makes sense (code, scripts, config management states). With that said it's a pretty daunting subject if you have no idea what you're doing (like me most of the time!) and you'll need to do a fair bit of reading and I would heartily recommend this book
C++ Primer (https://www.amazon.com/Primer-5th-Stanley-B-Lippman/dp/0321714113/) as /u/sempuki mentioned.
It's clearly written and is really good at teaching you modern c++ concepts and conventions, while many other c++ books are actually "program c using c++" books.
There are more bad sources of learning C++ on the Internet than there are good ones. I am not familiar with LearnCpp.com but looking at just a handful of its chapters it is misleading, out of date, violates a number of C++ idioms, and focused on the wrong things wrt. learning C++ specifically.
C++ Primer 5th ed. is a very good book for getting started with modern C++.
C++ Primer (5th Edition) it's good to start https://www.amazon.com/Primer-5th-Stanley-B-Lippman/dp/0321714113/ref=sr_1_1?ie=UTF8&amp;qid=1496834580&amp;sr=8-1&amp;keywords=c+primer
Try to avoid books like "for Dummies" or "Teach Yourself".
I would recommend not looking for C# specific books. Language specific books tend to get out-dated very fast and won't be as high of quality.
For this reason you want books like https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844 and https://www.amazon.com/Computer-Programming-Volumes-1-4A-Boxed/dp/0321751043
&#x200B;
I'm personally in the market for data structure books, sadly its a slippery slope when you already have a few.
> I want to gain knowledge and learn more by reading and thinking
Say no more, I have your answer
Refactoring is a classic, and surprisingly readable.
http://www.oreillynet.com/ruby/blog/2006/03/transformation.html
Two things: The coursework from my CS degree, and reading books about software engineering.
I've spoken in other places about the former, and for the latter, I recommend The Pragmatic Programmer, Code Complete, and Design Patterns: Elements of Reusable Object-Oriented Software
In all fairness to him, it was when you showed enough merit in your work.
And one can make a great deal of progress in 4 years of real world software development. But by the language of highly recommended The Pragmatic Programmer: From Journeyman to Master, you were almost certainly still a journeyman back then. I would guess it took me > 10 man years to obtain mastery.
They seem a like reasonable starting point I think. Repetition is the mother of mastery, the more books the better (in addition to applying what is learned).
Since Mosh is calling out learning fundamentals as important to becoming a good C# developers, I would personally also recommend some general (non C# specific books) too for who are starting out in software development:
There's a ton more, but those are a few that stood out to me. Essentially the more the merrier in my opinion - books, courses, videos, tutorials, and so on. The books I'm recommending here focus on adopting the developer mindset and being successful at it. That's part of the puzzle.
The other part is understanding the technical details including the programming language and frameworks you intend to use.
And finally, for learning about C#, I do highly recommend Mosh's videos/courses (some are free on YouTube, others available on Udemy). He's got a unique ability to explain things clearly and simply in a way that beginners can pick up quickly.
What I'd do is check out his free content first, and if you agree his style is ideal for learning, an investment in one of his courses is well worth it since he'll cover a lot more breadth and depth on each of the topics and they're organized into a super consumable package rather than scouring the internet for various topics.
Clean Code: A Handbook of Agile Software Craftsmanship by Robert C. Martin, amazon link on the [internet] (http://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882)
Buy Clean Code (https://www.amazon.ca/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882). This book is my bible. Read it through once quickly, and refer back to it once in awhile, and I can guarantee you'll never write spaghetti code again.
Some more:
The Art of Scalability - Well, the first 2/3 of it.
Scalability Rules - Very good, very short.
Continuous Delivery (I'd argue this is the single most important book in the software industry in the last 10 years)
The Little Redis Book - Free download!
The Little MongoDB Book - Free download!
The Varnish Book - Available as a free PDF if you fill out a marketing form.
Can I offer some food for thought?
On Clean Code, Robert C Martim said that functions should have, at most, 5 parameters. After that, it's a mess.
You should probably look into ways of reducing the number of parameters. Maybe 3 or 5 of those are related to a single object, with related functions.
Just a suggestion.
PS: Also, I think you'll get a Pylint error about too many instance variables, or something like that.
If you're looking for books that contain info on auto, lambdas, and any other new C++11 stuff, you're going to have to wait a little bit, as the standard is still very new.
If you're looking to get started though, I would suggest something like Effective C++ which contains a bunch of specific things you can do to write better C++ code. For learning the language, something like Programming - Principles and Practices using C++: it's an intro to programming textbook that focuses entirely on C++. I know you're not a beginner ;) but I've heard really good things about that book.
Basic:
C++ Primer
Effective C++
Effective STL
Advanced:
More Effective C++
C++ Coding Standards: 101 Rules
C++ Templates The Complete Guide
Large Scale C++ Design
I don't know what is that book's style but these free programming books/courses will strengthen your knowledge of the basics and introduce you to more complex stuff :
Best commercial book in my humble opinion is Effective Java by J. Bloch. He wrote parts of the standard library. This book just makes you a better programmer.
Also the most upvoted Java discussions on Stack Overflow will teach you a lot.
If you want to gain a bit of confidence in writing good Java code i'd start by reading Josh Bloch's Effective Java. It's a fantastic reference manual to have on your desk...
Check it out here
I believe this is a pretty good book for legacy / maintenance systems:
https://www.amazon.com/Working-Effectively-Legacy-Michael-Feathers/dp/0131177052
I highly recommend the book Working Effectively with Legacy Code by Michael Feathers. It has a bunch of practical tips for just this situation.
Yes. But it’s a great paying skill. There are techniques for working with legacy code.
This is the go to book for it.
https://www.amazon.com/Working-Effectively-Legacy-Michael-Feathers/dp/0131177052
I am not a great coder, but I had to deal with this bs in the past.
Find where the data structures are, figure out the layout then focus on the transformation. Legacy code usually has some core logic (10%) and a whole bunch of one off hacks bolted on (90%).
Buy this book.
http://www.amazon.com/Working-Effectively-Legacy-Michael-Feathers/dp/0131177052
Financially plan for getting fired tomorrow. Save money, don't get locked into long term rental/mortgage. Reduce your debt burden if you have one.
Senior dev here who is on the other side of things. One way to approach these situations is to try and approach the problem more from the business case. I’m not sure of your work culture, but you should be bought in as to why a deliverable is time sensitive and what there is to gain by delivering this week vs a week or two later. If people don’t have reasons, they need to be held more accountable for the longer term delivery. Tech debt is a slow killer. You’d be surprised with how much you can push back:
How is this feature being measured?
What is success criteria?
What are the next steps if successful? If unsuccessful?
What are we not doing in order to do this task? Is this the most impactful thing we can spend our time on?
Also, understand that any system is due for a rewrite every 4 years or so. No matter how clean you write, you’ll eventually have to refactor anyway. You defiantly want to maintain something workable, but keep in mind there is no such thing as a permanent solution.
And finally, Great book ok how to make small iterative improvements as you go.
Working Effectively with Legacy Code https://www.amazon.ca/dp/0131177052/ref=cm_sw_r_cp_api_i_Td0QDbFQKYV3T
The book "Expert C programming: Deep C Secrets" link is pretty good with that kind of stuff. Also there are a ton of jokes so it's not a dry read
> there is no documentation
Documentation typically, at best, describes only what the original author originally intended, and as you noticed, can become quickly obsolete.
Instead, another approach is to write cleaner "self documenting" code, which includes several concepts such as meaningful/descriptive names, single purpose principle, and several others. If you are interested in these concepts, I highly recommend "Clean Code" by Robert Martin.
> 30+ character length method names
Long names are not always always terrible; the more important question is are the names meaningful and descriptive? I recently worked at a place, where class and method names were of similar length to what you describe, and was originally extremely annoyed at the length. After reading the previously mentioned book, I was no longer annoyed at the length, but realized what bothered me the most was that the names were terrible and confusing, the code was poorly formatted, and the names had to be long because of excessive violation of single purpose principle.
Long names can make code easier or more difficult to read. Again, read Clean Code, and you'll have a better understanding and be able to better articulate what is wrong (and perhaps even fix it).
> There's water cooler talk about a method that's over 2,000 lines long.
Definitely a code-smell. My guess is the 130-char name, and 2000 line method violate single purpose principle quite heavily.
> My job: dead code removal.
Entry/Intern level jobs tend to be mundane grunt work that no one else wants to do. I'm not saying that to make you feel better, but rather so that you'll understand "why."
> When we do our daily scrum nobody even understands what I'm doing
Is your team almost purely interns?
> All our tests are broken now. All of them. Production is halted. Why? An execution script needed to have a flag added to it, the commit was made from a Windows machine, and now it's sitting on the trunk of our repo being deployed to all of our testing environments.
Code review and testing failure, especially given you're an intern. Your next paragraph seems to indicate your interaction with the "thing" somehow was part of a process that caused everything to break (though it wasn't specifically you that broke it)?
> What do I do?
5 years from now, it won't matter. The stress you are experiencing is not healthy, and will matter 5 years from now. Relax, stop stressing, the worst they can do is fire you... which is probably not a terrible thing and unless you're hurting financially. Go home on time, work at a consistent pace, and take care of yourself. Polish your resume, and find another company that is more sensible to intern at.
I've been reading Clean Code: A Handbook of Agile Software Craftsmanship and chapter two discusses this, and agrees with you. Interfaces should not be suffixed with 'interface', and if you run into naming issues (wanting to name the interface and the class Product) you should lean towards naming the interface Product and the class ConcreteProduct.
I started following this practice and it makes a lot of sense after you start working this way. If I'm making an interface it means anything which implements it should be valid, so I should never type-hint a concrete implementation, I should only ever type-hint the interface. Adding the Interface suffix is just adding verbosity and possible confusion.
Steps to build your own engine from scratch with no knowledge:
Note: Most people who decide to put together a voxel engine take about 2 years from inception. At the end of the two years, they will have a library they could use to create a game. They've also already made it through the first 4 steps when they start.
Without a degree program to solidify the concepts, I suspect that the first 4 steps will take at least 2-3 years: about 10-20 hours per week each week.
Not really.
If you're already familiar with basic programming and just want to get into C++ then: A Tour of C++. If you want to learn to program, and use C++ while doing so, then try Programming: Principles and Practice Using C++
I play with C++ as a hobby. I'm very far from being even good at programming in this language, but I'll tell you what I've done so far.
I first read this book: Programming: Principles and Practice Using C++ (2nd Edition). This book is written by the very man who developed C++.
Now, I know it looks daunting since that book has about 1200 pages, but a lot of it can be skipped if it doesn't pertain to what you want to learn.
After reading that book and making a couple small programs, I decided that I would give SDL2 a try. SDL2 is a 2d graphics library that includes window management. I did this first since it has a lot of documentation on how to use the library, and you can usually google something if you have problems. SDL2 can also be used in conjunction with OpenGL, so it is worth at least getting familiar with the library.
After all of that (at this point, for me, it had been about 2 months of off and on practice), I finally googled how to learn OpenGL. I followed some tutorials and tried to make some programs, but I learned that OpenGL was way over my head. I was able to get a few small programs running. There was one program I made that procedurally generated terrain, but I learned that OpenGL really isn't necessary if you want to JUST make a game.
When using OpenGL there is a lot of code that you will use over and over again, resulting in you sort of developing your own makeshift scene manager. You'll also want to learn how to program shaders, I haven't even done this yet, but this doesn't only apply to OpenGL. You'll probably want to learn how to program shaders no matter what.
So, after dealing with OpenGL and its steep learning curve I decided to give some rendering libraries a try, and this has been the best course for me to take. Here's a list of rendering libraries. I use Irrlicht because it is relatively lightweight, easy to use, and setup. Irrlicht isn't really updated too often so you won't get the latest features.
If you really want to learn OpenGL then this is the tutorial I followed: Link. It even has information on how to use SDL2 with OpenGL. This will get you started at least.
As for the IDE I use, Netbeans. This is mainly for Java, but it works well for C++. There are all kinds of IDEs you can use, just search around Reddit for other people's opinions of what they like.
I hope I helped! Ask me any questions you have and I'll try to answer them, just note, I'm not even close to a professional developer. I just like to program and play with graphics!
EDIT: Oh yeah, if this makes any difference to you, I did all of this on a Linux distro.
O Steve Yegge fala uma coisa que é o seguinte, você não pode dizer que sabe uma linguagem de verdade até conseguir escrever um compilador dela.
Por isso, se você quer viver de uma linguagem, é melhor encarar logo um camalhaço de mil e quinhentas páginas que ensina tudo de cima até embaixo do que tentar ficar aprendendo gambiarra ( e no caso de python tem muitas ).
I think /u/swingking8 was spot on when s/he said to find a project that captures your interest. You'll be using the language and not just following a tutorial.
But, once you have a feel for the syntax, I can't recommend strongly enough that you look up presentations and writing by Raymond Hettinger and David Beazley.
If you learn best by reading before doing, Mark Lutz's Learning Python seems intimidating because of its size. But it's so big because it is both comprehensive and accessible for beginners. So depending on what you already know, you can skip large parts. But if you really understand everything in that book, you are well on your way to being an intermediate level Python dev.
Looking at your posting history you really need to pick up a book or two. Very unfocused learning going on here.
OpenShift is probably the most unusual way of deploying or learning how to deploy Django. This is confounding your learning troubles. Omit OpenShift.
If you already know Python, skip this one, but at least think about it: Learning Python. Then.
Pick up Two Scoops of Django. Learn it, read it. All. Local. Do not use a "real" database, use SQLite. Do not think about deploying at all.
Once you're comfortable with Django. Experiment with understanding what a database actually is, how it works and how to administer it, how to configure it. How to configure it with Django. Use something other than MySQL, which invariably means Postgres.
Once this is done and I mean done. Only then is it time to think about how to get deploying Django. Use a VPS, do not use a magical "we'll do it all for you" thing. It's just clouding too much for you to clearly understand what's going on. It's hindering learning. Omit things which cloud understanding.
That's an interesting pattern you have going on there. I don't know what kind of background you're coming from, but one of the nice things about Python is that, being dynamically typed, you can pass almost anything to a function at run-time.
What that means is, you can have a function like a spell that expects a
characterobject, whether it's p1 or p2 is irrelevant. It holds the logic of how to access the object and alter the attributes. There's a LOT that goes into how you design that, but that's a thing that literal books have been written about.So, as a brief example, you might do something like this:
def fire_spell(target):
target.spell_hits('fire', damage=2)
return target
class Character:
def init(self, name, health=10, mana=10, immunity=None):
self.name = name
self._health = health
self._mana = mana
self._spells = {
'fire': fire_spell
}
@property
def health(self):
return self._health
@property
def mana(self):
return self._mana
def cast_spell(name, target):
self._spellsname
return self
def spellhits(self, type, damage=1):
if self.immunity == type:
return None
else:
self.health -= damage
return None
So let's break that down a bit:
fire_spell: Exists outside of the characters. I would probably put all my spells in a separate module, that way I can import them, and add and remove them at run-time from the characters. That enables you to do things like have spells that aren't accessible prior to a level up, or some other mechanic. This isn't too different from having a separate class for the moves, since you're trying to namespace the moves, but I'll get to where that's a little odd here in a second.self._health: This is just an attribute, but note the leading underscore. This is a pythonic convention that tells anyone who is using your code not to use this variable to access the thing that it points to. That is it would be best to leave it private. Python doesn't have private variables, so this is as good as it gets. We're all adults here.@property: This is an example of a built-in decorator. If you don't know what decorators are, there are TONS of tutorials out there. Essentially, they modify how a function works. This one makes it so that instead of having to call the function, e.g.player1.health(), you simply access it as an attribute a laplayer1.health. Why on earth would you want to do this though? Well, any code in the function will run prior to returning the attribute! This allows you to modify what the calling code receives when it accesses the attribute. You want to have a conditional health buff based on the zone that the character is? Boom, way easier with this pattern. What to have the mana get dropped to 0 because of a status effect, easy peasy. And as soon as the effect clears, it can go right back to where it was! Basically,@propertyis really cool.spell_hits: This is a method on theCharacterobject. This you know. But why is it there? Well, designing a game is essentially designing an API. You may have heard of API around town, usually people are talking about web APIs, but the term is Application Program Interface. It applies equally to what this is. TheCharacterclass exposes an API to function inside of your program. They can expect that if they're going to receive aCharacterthen they can act on it in a certain way. This is actually where you start to understand why certain programmers really aren't fans of dynamic typing. Python gives precisely 0 shits what you pass to this function. You can pass it a list of integers and it will not be annoyed. Well, until you try to callspell_hits. Then you getPropertyError: list object has no method 'spell_hits'. This won't happen until runtime. Then you're stuck chasing down which part of your gaht DANG CODE PASSED IN A DAMNED LIST!!!!! This probably won't happen to you with a small program, but I like to add context!return self: Why would you do that? Well, we're back to the concept of API design! It's a pattern used for a "fluent interface". This pattern allows you to utilize method chaining, which is a really nifty thing. For example, let's assume that you want to run specific series of methods on a certain user input, then you could dop1.cast_spell(p2).use_item(p1).another_method(). This is a pattern that you see in a lot of libraries. It helps wrap your head around it if you write some code yourself that does it.As far as your code is concerned, there's on thing that really sticks out:
Attributes.init(self)
Moves.init(self)
You don't need to explicitly call
__init__. The__init__function is what a lot of pythonistas refer to as a "dunder method", short for "double-underscore". I prefer to call them "data-model methods", since that tells you what they're actually a part of, instead of describing how they're written (which is totally useless information). A bit pedantic? Totally, but I wouldn't be a programmer if I didn't have a pedantic pet peeve (how's that alliteration!)Data model methods are called when they need to be, and in the case of
__init__that is when you initialize an object. Example:class Thing:
def init(self, name):
self.name = name
t = Thing('bobby brown')
print(t.name)
That will output
'bobby brown'because we assign the newly initializedThingobject to the variablet. Without capturing the object with a reference to a variable, they will be garbage collected. Basically, theAttributesandMovesobjects that you're initializing will not be attached in any way to the player. You would need to do something likeself.attributes = Attributes(self)
Which would allow you to reference the new objects inside your player. Garbage collection in python isn't something that you'll need to be concerned about often, but I mention it because it's nice to know that python uses reference counting. Well, C Python does, and you're probably using that, so....
Overall, I think that what you need to get coded (pun intended) into your brain is the idea of frist class-ness, specifically as it relates to python. This concept is what makes decorators possible, and underlies the design patterns related to classes. I would also highly recommend the official tutorial as a place to find solid info on basics.
Past that, really it comes down to design choices. There's a million other ways than the one that I gave you to do this. Each one has a good reason to do it, and each one has trade-offs. This is where the rubber meets the road! Real programming boys! If you're interested in reading something that might help, I recommend Clean Code as a good read on designing good reusable software. The design book I linked above is kind of dense and uses Java, which could be confusing if you don't have experience with it. Clean Code is more generalized.
TL;DR: Functions accept objects, so pass the player object to the function and alter the health there. Then go read a LOT of stuff on OOP design patterns, cause they're hella hard.
freelancer.com, upwork.com και παρες όσες περισσότερες δουλείες μπορείς. Βιβλια που μπορεις να διαβασεις:
https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844/ref=sr_1_2?ie=UTF8&amp;qid=1482103739&amp;sr=8-2&amp;keywords=algorithms+and+data+structures
https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882/ref=sr_1_4?ie=UTF8&amp;qid=1482103757&amp;sr=8-4&amp;keywords=software+engineering
Αν δεν ξέρεις κάτι google it. Η Ελλάδα έχει μεγάλες προοπτικές ανάπτυξης και πολύ καλό βιοτικό επίπεδο. Αν καταφέρεις και κάνεις κάτι μπορείς να βγάλεις καλά λεφτά κάνοντας εξαγωγές. Έχουμε υψηλό μορφωτικό επίπεδο σε συνδυασμό με το χαμηλό κόστος βιοτικού επιπέδου είναι θέμα χρόνου μέχρι να αρχίσουμε να εξάγουμε competitively priced τεχνολογία.
Αν εχεις ποιο συγκεκριμενη ερωτηση πες μου
C# in Depth likely isn't what you need. That's more aimed at proficient coders that want to understand the nitty gritty/internals.
Clean Code: A Handbook of Agile Software Craftsmanship (Robert C. Martin) is very popular. Not specifically aimed at C# (a lot of the examples are Java) but it's guidelines about how to write clean code in general. The lessons carry over to all/most languages. That's probably more the sort of thing you want.
https://www.amazon.co.uk/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
Robert C. Martin aka 'Uncle Bob' also has a few other books but I've not really looked into them. e.g. this one is focused on C# and looks decent based on a quick skim of the index but I've not read it:
Agile Principles, Patterns, and Practices in C# (Robert C. Martin)
https://www.amazon.co.uk/Principles-Patterns-Practices-Robert-Martin/dp/0131857258
Alright, in that case it sounds like you can benefit from 'the general advice':
The most important thing when looking for a Java developer job is to actually understand Java. I don't mean knowing how to write code in Java. I mean knowing how the language works. What is the purpose of equals/hashCode, how to make object Immutable, what is the String pool, etc...
You would be surprised how many developers think they understand the language and have no clue how it works.
You do not need all these things to get a job. There are plenty of large IT organizations that will just hire lots of people to fill seats and then drop them if they don't work out. However, if you want to get a job at a company that is serious about producing quality code, you need to show that you are serious about being the best developer you can be. Getting a job at an organization like this will not only pay better but you will also have the opportunity to learn from all the highly skilled developers that work there.
Since it's only a few weeks and you will use Java primarily, probably look primarily at the Java API's / components:
https://docs.oracle.com/javase/8/docs/index.html
(honestly can't find this overview page for newer versions java)
Collections-API is a good start (Map, List, Collection and so on and their implementations), I/O (read and write files), Concurrency/Multithreading (also understand the concepts), JDBC (connect to a database, read and write data). Date/Time-API. Probably networking.
Also learn all the language features. E.g. that there are three different kind of comments, know "all the keywords" (what's volatile and transient? I always mix them up ...), or what is try-with-resource?
If you're decent with java, you'll have,... let's say "one problem less"
&#x200B;
Learn OOP/OOD: Read and understand those concepts is a good start: SOLID, Loose coupling, High cohesion, Information Hiding. Those concepts we do apply, so we can reuse parts of our code (so it's not duplicated), improve maintainability, interchangeability (like changing the front end technology to display the website without redoing the whole software), and so on. Not sure if that's too early for you, in the sense, that you are still learning the language and learning another "thing" is too much.
&#x200B;
Databases are already mentioned (many applications use a relational database as 'backend'): Setup a database (e.g. postgreSQL or mysql, both are free), learn how to create tables (columns, datatypes, primary keys, [indices, constraints]), crud operations (create, read, update, delete data), how to restrict selection of data (where clause), how "to join tables", functions (max(), avg(), count()). Imo the basic concepts of 'relational databases' and how you get/change data is quite easy compared to learning a programming language.
&#x200B;
Read Clean Code. (Probably too early for you, but I leave it here)
&#x200B;
Probably have a look at HTML/CSS/JS. I really like w3schools, but mostly as a reference, because I don't know these by heart. Not sure if you have enough time, but try to learn some of the components of html and learn how to style them. It's actually quite easy compared to Java. If there's enough time, to learn some JavaScript may be helpful, too.
&#x200B;
... and now combine everything :P - no, seriously: "Ship" a product - even if it's something small and irrelevant. To break down a problem into smaller problems and combine everything we know to solve those problems with the most elegant solution is what we do day in day out. And get your code reviews (e.g. here on reddit, the stackexchange-network has a good code review network, too). Because there's always a better and more elegant solution. If no one tells you, your code sucks (... or can be improved) and why, you keep writing bad code - or at least you won't improve as fast.
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.
Read and adhere to the guidelines presented in "Clean Code" by Robert Martin (Uncle Bob). The book could have been written as a response to this question.
Edit: krogger pointed out I misattributed the work. This has been corrected. Thanks Krogger.
That's exactly how you should code. Uncle Bob taught us that.
Uncle Bob is love, Uncle Bob is life.
Read his book
One book I recommend to my CTO friends is The Clean Coder. It really helped me set the culture for how our development team should behave themselves. I bought a copy for everyone on my team.
I also strongly recommend Hooked. If you're at all involved in the product management side of things, this really helped me understand how to build an engaging product.
Many of my fellow CTO's recommend Extreme Ownership. The idea here is that as a startup team, you have to be willing to (figuratively) die for one another, and you have to have each other's back the way a platoon in combat would.
Depends what you want to learn. Some of my favorites are
This a good list to get you started :) most of my favorite books are not language specific.
I'd say if you want to do it right then this book will show how
https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882/ref=sr_1_1?ie=UTF8&amp;qid=1496679937&amp;sr=8-1&amp;keywords=clean+code
Like most time in my job, I dont have alot of time to look at code, so something I find important is how clean / understandable the code is and at a glance its where I'm struggling with your code.
In particular, process request seems to be 200 odd lines long, doing many things and branch / nests alot and to understand you have to delve in to the guts of it and also read comments (which on shared code will go out of date). I think the complexity would really show if you try to unit test the code.
Clean Code is an awesome book on the subject. At times may go over the top a little but the message is great.
So to break that method down and make it cleaner / more understandable you can do 2 things. Firstly, small private methods that self document:
For example in the middle of the method you do this with a comment:
//----- DATA SEPARATOR -----//
String delimiter = "\t";
if ((REQUEST.get("FILE_DELIMITER") != null) && (REQUEST.get("FILE_DELIMITER").length() > 0)) {
String sep = REQUEST.get("FILE_DELIMITER").trim();
if ("COMMA".equalsIgnoreCase(sep)){
delimiter = ",";
} else if ("PIPE".equalsIgnoreCase(sep)){
delimiter = "|";
} else /if ("TAB".equalsIgnoreCase(sep))/ {
delimiter = "\t";
}
}
could be extracted to this:
String delimeter = getDeliminator(request)
....
}
private String getDeliminator(Request request) {
if ((request.get("FILE_DELIMITER") != null)) {
String sep = REQUEST.get("FILE_DELIMITER").trim();
if ("COMMA".equalsIgnoreCase(sep))
return ",";
else if ("PIPE".equalsIgnoreCase(sep))
return "|";
}
return "/t"
}
The advantage with that extraction is now processRequest has got smaller and there is now 1 line saying get delimeter that I can understand straight away because the name of the method is saying what its doing. Because of that you don't need that commend and the code becomes self documenting.
Its also simpler because there is no longer variable being defined with a default value that may or may not get overriden.
The delimeter calculation logic is now wrapped up in a nice little method that does 1 thing. Ultimately processRequest doesnt care how the delimiter is calculated, just that it gets one.
Everything has got a little cleaner and simpler.
So yeah there's many places that that sort of extraction / self documentation will help. Generally speaking a method should do 1 thing, if its over 4 lines long then it may doing too much (ok that quite extreme, but long methods are a sign of methods may be doing too much)
The second thing that may help is breaking that class up a bit. Its doing a lot, processing request, generating a file, doing all sorts of things with processing, writing the file out.
If you break things up a little you can reduce the complexity of whats going on, i.e. process request process the request and leave it up to something else to do file generation etc.
Its handy because it greatly simplifies testing, you can then starting testing the individual components. More along the single responsibility type idea.
A couple of other quick things I noticed, only use CAPS variable names for static instances. You have dual variables request and REQUEST doing differrent things,, i dunnore, request and requestTable?
Theres also a couple playes where you are catching an exception and doing nothing, it supresses the exception, generally thats bad, at least do a stack trace or log the exception happened. Its hard tracking down bugs / odd behaviour when exceptions are suppressed.
Just gonna say it; if you're not using function and/or class definitions in every file then you haven't learned Python or programming. Not yet.
Most of professional programming is maintaining code, usually in concert with others; you must be using factorization primitives -- in Python that's functions, classes, and modules -- to write code that is even testable, which is the start of being maintable.
I would suggest starting with a book like Clean Code.
Amazon
Goodreads
Wikipedia
The Pragmatic Programmer http://www.amazon.co.uk/Pragmatic-Programmer-Andrew-Hunt/dp/020161622X
Has a lot of similar stuff to Code Complete 2 but not quite as dense so makes a good primer.
Best book to learn C++ in my opinion is Accelerated C++: Practical Programming by Example (350 pages). Right from the start, it teaches people to use STL containers and other C++ constructs, instead of teaching "C with classes" like many other books (including Thinking in C++). Unfortunately, it is outdated so you will have to learn about new features of the language. You can use A Tour of C++ for that(180 pages).
If you have the time and will to learn moder C++ from the start, then I would recommend C++ Primer. Similar in approach to Accelerated C++ but longer(970 pages).
>What are some good guides/practices to unit testing?
Test Driven Development: By Example is a good book to get started with
>Say I have an app with dozens of functions, how do I choose which functions to write tests for, and are there preferred style guides for these tests?
Ideally, you would test them all and you would want to write unit tests and integration tests for them.
>If it helps I want to begin by testing the front end code, whether it's generated with a framework like React or more bespoke using template strings. How do you conduct "recon" on your code to pick the targets to write tests for first, and how do you choose your testing framework?
I've never used bespoke so I can't comment on it but for React I'd recommend jestand enzyme. Jest is a testing framework that was created by Facebook (the creators of React). It's not specifically designed for React but it works great with it. Enzyme is a library made by Airbnb specifically for testing React components. Enzyme is designed to work along side Jest.
>I know you need as much coverage as possible but since you gotta start somewhere, how do you pick the starting point in your code?
The most critical part of your application
Well, time to get a good C++ book then. Here's a decent one:
https://www.amazon.com/Primer-5th-Stanley-B-Lippman/dp/0321714113
I am not even kidding here - programming is not something you learn in a day or two. It's a process that lasts hundreds of hours. Meaning you will need to practice and for that you need resources.
Well, to be fair - it really depends on your aptitude and a professor in question. If you were just told to have specific output but nobody has explained basic syntax ahead of the time then it's a shitty course. But if it was covered during the lecture and you just dozed off then it's on you. Well, one way or another it means you will need an extra time at home with a decent resource to work out your problems and learn programming.
Also - be a bit more specific. What kind of programs are you trying to write and what actually causes you problems? Literally not knowing how to write a line of C++? Or not being able to understand a problem and finding a solution to it?
http://www.amazon.ca/Primer-5th-Edition-Stanley-Lippman/dp/0321714113
There are two books with very similar names (C++ Primer, and C++ Primer Plus), and usually, this is the one that's being referred
> What's next?
I read plenty of websites to help out new or aspiring programmers, but this theme repeats like a thousand times and I just don't understand it. It's probably an issue with the system, but even then I still don't get why people are this way, it's as if they are not thinking...
Anyway. "What's next?" is immediately obvious to any rational person.
> I'm interested in making a game.
You do that. Tadaaa fucking done why did you even ask.
The problem is people are learning stuff for learning's sake. What the flying fuck? I just don't get it. You should learn stuff because you want to do something. You, OP, actually know what you want to do, making a game, so just... start? You will encounter plenty of problems along the way. You will research those problems and learn a huge amount.
If you notice you are lacking fundamental skills and just don't make any progress, read a fucking book. Have people forgotten that there are books on topics to learn those topics? I entirely taught myself C++ just by reading this, I have infos on how to get it if you want.
Also Go to StackOverflow and read the top 1000 questions (or how many you want).
There are so many resources on the internet... so many blogs to follow and read, so many tutorials to do.
I'm a little bit sorry that this is a rant, but I also included plenty of information so don't you fucking complain.
I'm kind of in shock no one has mentioned getting a good programming BOOK.
book!
Read it. Do the examples, answer the questions, experiment and break stuff.
Perhaps offtopic but... Some books you should read regardless of CompSci branch
There are several good books on designing good software:
Code Complete
Design Patterns
Refactoring
First of all, this is an excellent post. I've seen so many questions posted here but yours is the most concise and upfront. I know exactly what your background is and so I'm more confident that what I want to suggest would actually be relevant.
You have solid industry experience with academic foundation. And I think you already are aware of the pitfalls of expert beginner (http://www.daedtech.com/how-developers-stop-learning-rise-of-the-expert-beginner/). I think you are in a sweet spot where you can afford to invest resources without immediate gain - unlike early-career coders, you don't have to necessarily learn another language/framework right this second. You can afford to deepen your higher-level understanding of concerns and concepts that are timeless and not bound by the language/framework of the day.
I'd like to suggest you read other people's code/design. Here are some books to get you started.
Another thing you can invest in is everyday skills as a programmer. This is a classic on this subject.
You can couple ideas and tricks from here with any devops tools of the day to automate much of your workflow, such as bash/git/unix concepts onto automation tools such as docker/jenkins/ansible. Additionally, familiarizing/customizing your personal development environment. Improving scripting skills to automate many many things (practically everything that we do on computers that doesn't involve creative process are automatable. It's just a matter of ROI.).
Code Complete
Big Java Late Objects
The Pragmatic Programmer: From Journeyman to Master
The Mythical Man-Month
Android Programming: The Big Nerd Ranch Guide
cracking the coding Interview
Introduction to Algorithms
Thinking in C++
This list isn't about "coding" per-se but is more focused on concepts, sw.en., practices, etc.
Thinking in Java is one of my favorites, the definitive introduction to object oriented programming and design.
Code Complete, Don't know anyone who hasn't heard of this so far
The Pragmatic Programmer: From Journeyman to Master
> Knowing one programming language, is of course, a must for any sort of programming. Knowing many programming languages is a bit less important, in a way. Many languages are very similar to one another and aside from the keywords, the syntax largely remains the same. If you've done Java before, then this means you could very well hold your own in C++, C#, and VB.NET for example.
I'd disagree strongly on this one. Writing VB.NET is very different from writing C++. I'd argue that programming language paradigm is more important. It's easy to switch between languages following the same paradigm because, beyond frameworks, libraries, and syntax, they are very much the same.
>Whenever possible, seek to make your functions about a screen's height. It's easier to follow the flow if you don't have to scroll up and down all the time.
Huh? That's a weird way to explain it. What's more important than number of lines is the Single Responsibility Principle. Every contextual item in your program (class, method, variable, etc) should only have one responsibility.
Otherwise I'd agree with this advice. For these little quips like these check out The Pragmatic Programmer, which is perhaps one of the best books that helped me move from a novice/junior developer to an intermediate/senior dev.
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:
This is from my own personal experiences. Please, learn Java first, I cannot stress this enough. Knowing Java helps so much with design, I struggled with basic Java knowledge and hated programming for Android; I recommend Effective Java 8th Edition .
Be warned though, it's not very friendly to novice programmers, so I'd make sure you have experience in any 'C' based language beforehand - C++ would be a great help.
I'm really not trying to be a dick here, but you really do need to learn Java to a sufficient level. Do you know: Java Inheritance, Static Functions, Abstract Classes, 'For Each' operator? Mutaor Methods? Trust me, this will all come up in Android and more over, Android uses most of Java's library.
Please, I don't want to sound like a huge Dick, but this is crucial. Let me put this is into a metaphor. Learning the Android API without Java is pretty much suicide (I can't think of any good metaphor(s)).
I hope this helps, Oh and Inbox me on Reddit - I might have a few books for you.
Effective Java
Head First Design Patterns
http://www.theserverside.com/
http://stackoverflow.com/questions/tagged/java
[Test Driven Laravel] is an excellent resource for people who are new to testing, even though it is tailored to Laravel. There are plenty of concepts you can apply to other languages/frameworks, though.
[Growing Object Oriented Software Guided by Tests] is a book that really helped me understand testing, especially test first. The examples in the book are in Java, but again, the concepts apply to other languages. The Test Driven Laravel link I provided is very clearly inspired by that book.
I'm really surprised nobody has included the books by [@grmpyprogrammer] since he's fairly well known as the "testing guy" in the PHP community. I believe all of his books are on his [Leanpub].
[Test Driven Laravel]: http://testdrivenlaravel.com
[Growing Object Oriented Software Guided by Tests]: https://www.amazon.com/Growing-Object-Oriented-Software-Guided-Tests/dp/0321503627/ref=sr_1_1?ie=UTF8&amp;qid=1525976055&amp;sr=8-1&amp;keywords=growing+object+oriented+software&amp;dpID=51fUKOog3VL&amp;preST=_SX218_BO1,204,203,200_QL40_&amp;dpSrc=srch
[@grmpyprogrammer]: https://twitter.com/grmpyprogrammer
[Leanpub]: https://leanpub.com/u/chartjes
Edit: Apparently I needed to refresh before posting as other people have linked up to Grump Programmer.
You might want to check out this book:
Think Like a Programmer: An Introduction to Creative Problem Solving https://www.amazon.com/dp/1593274246/ref=cm_sw_r_cp_api_i_QOnEDbQBH1PW0
For me, I find the trick is trying to break down the problem into the smallest steps. For math related stuff I often do a few iterations on paper so I can see where the patterns lie and answer questions like “what repeats here” which would tell me I need a loop or recursive function. Or “what decisions does the computer need to make? Using what information?” Tells me what conditionals I’ll need etc.
For Fibonacci, for example, you know adding is involved.... so you are going to need math operators. you know it repeats ... so you’ll need a loop or function. Etc.
I hope that helps!
This is something simple that could be accomplished with most languages, and it's very simple to do in Python.
I believe Automate the Boring Stuff covers everything you'd need to accomplish the task.
Have this book, love this book. I highly recommend Automate the boring stuff. This was a much better kickstarter into learning the program language for as it has real world applications you can do. I tend to drift back and forth between the two books all the time.
Also, good to note, the Author is a redditor ( /u/ehmatthes ) AND posted the book here for free but I bought two copies just because I loved it so much. (Kindle and paperback, I'm not crazy!) If these books came in hardcover, or pocket sized I'd probably own four copies then (NUDGE NUDGE WINK WINK HINT! HINT!)
Good post to read and print
https://www.reddit.com/r/learnpython/comments/4y06nq/beginners_python_cheat_sheets_updated/
If you like reading and referencing a book while coding I absolutely suggest "Automate the Boring Stuff with Python
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](http://blog.codinghorror.com/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.
When you're working with other people, it's probably better to follow the code conventions set by the team or the company. That's for consistency and making your fellow programmers' lives easier.
Otherwise, I recommend you read Clean Code. You'll learn a lot about proper commenting, separation of logic into functions (Uncle Bob recommends short functions), and many more!
I've learned to enjoy writing similar to how Robert Martin outlines in his book, Clean Code
If I were to write this specific code by it, it would look something like this:
function retrieve_all_items_from_storage()
{
$result = DB::select("SELECT id, item, description, cost FROM items");
return $result;
}
function format_item(&$item) {
$item->item = "Hello " . $item->item;
}
function get_all_items()
{
$items = retrieve_all_items_from_storage();
if(empty($items)) {
return array();
}
foreach($items as $item) {
format_item($item);
}
return $items;
}
However, I would never write my example into my own projects because there would be a lot more complexity to it. For instance, I would have the retrieve_all_items_from_storage implement a data mapper, and have it return a Collection object, where I would do $itemCollection->isEmpty() instead of empty($items). It would also be organized into a multiple classes because of the nature of the functions. So while this is not something I would condone in your software, I firmly believe it is almost always better to have your method names define what a block of code does, rather than jamming it all into a function and commenting it out.
-- Edit --
I seemed to have missed the original question. If I had to pick, I would say the second block of code for similar reasons to what I outlined above.
Well the whole boxed set costs $183 on amazon http://www.amazon.com/gp/product/0321751043/.
I'm currently studying from this book. Super easy to understand, and you'll get some decent projects out of it.
That's because the explanations aren't very good. You aren't alone in that regard. As one other suggested, there is Think Python.
I would also suggest these:
As for online resources:
You try the Invent Games with Python / Making Games with Python books, if dipping your toes into gamedev sounds fun.
I am working through Python Programming For the Absolute Beginner and that also has a focus on game-style projects. The first one will probably be a bit too easy for you, but More PPFtAB might be something that interests you.
In the interim, I suggest the following books:
&nbsp;
As for the coding books, I suggest you pick one up on Python or Java - I'm personally biased towards Python over Java, since I think Python's syntax and code style looks nicer, whereas Java makes you say pretty much everything you're doing. Both programming languages have been out for a long time and see widespread usage, so there's plenty of resources out there for you to get started with. Personally, I'd suggest going with this book for Java and this book for Python, but if you go to Coursera or Codecademy, you might be able to get better, more interactive learning experiences with coding.
Or you can just skip reading all of the books I recommended in favor of MIT's OpenCourseWare. Your choice.
This. I swear the best non-course instructed way is using this great e-book.
http://learnpythonthehardway.org/
Otherwise if that is what you are using already, then I recommend Learning Python 5th edition from the O'Reilly series of technical books.
http://www.amazon.com/Learning-Python-Edition-Mark-Lutz/dp/1449355730
Try Learning Python by Mark Lutz. It provides a comprehensive, in-depth introduction to the core Python language (Support Python 2 and 3). It's a hefty read, 1648 pages, only to discuss the about the core of Python.
Or his Python Pocket Reference might suits you better.
I would follow up on the courses delia_ann posted. I preferred the MIT course over the Harvard course for several reasons but YMMV.
I would recommend brushing up on math if you think you might have trouble, but considering you have an engineering background this may not be necessary. Before I started the program I worked through khan academy for several months and it helped me a lot in 225: Discrete Math.
Since this is the close of my first semester I decided I'm going to spend time off between semesters to take courses on edx and/or start reading the textbook(s) for my next class. Having rudimentary knowledge of the subject matter before the class starts makes things so much easier.
Someone on this sub recommended Think Like a Programmer to me, and that's what I'm using to reinforce concepts and get ready for 162 next semester (especially because it uses C++). There's a free pdf on that you can find using google. This may be a good read for you when you get a little experience using C++.
The correct answer to:
Q. Should I learn C or C++ first?
Is:
A. Yes.
WARNING: Highly Opinionated Analysis of C vs C++
I see a lot of people recommending one way but no one offering an analysis of BOTH the Pro's & Con's.
I've been using C++ since ~1990. I've briefly worked on a PS3 C++ compiler when I worked for Sony. I've seen 2 major problems over the years with C++ programmers:
1. People don't exercise discipline and restraint in K.I.S.S.
They use (and abuse) every language feature because they can. There is this tendency to over-engineer even the simplest things. Take a look at this complete clusterfuck of CRC in the Boost library.
1109 lines of over-engineered C++ crap for a simple CRC32 function instead of a mere 25 lines of code!?!?! The C version would:
The trade-off would be is that it is less flexible, but WHEN was the last time you needed to use a custom CRC polynomial!?!? One would instead use a different algorithm such as MD5, SHA, etc. that:
This excellent SO on hashing is but one example of focusing on the big picture.
2. People lack a basic understanding of the cost let alone the implementation of C++ expressions.
I've seen people stick a virtual function inside an inner loop and wonder why their performance is crap. I've seen people fail to grasp a basic understanding of pointers. I've seen people not understand memory management and how to guarantee zero memory leaks. I've seen people spend more time on writing an "über" template and waste hours debugging that instead of just writing something in 1/10 of the time and move on.
IMO, due to the bloated, over-excessive verbose nature of C++ it is for these reason that I strongly recommend a beginner learn C first and then learn C++. You'll have a better understanding of why C++ is designed the way it is, what the design trade-offs are/were, what C++ hacks are, and how to best use the languages to their potential.
However, this is ignoring the benefits and disadvantages of the Pro's/Con's of why one would learn C++ or C first.
Learn C++ first
Learn C first
{{With that said there are numerous C++ books I would recommend to ALL C++ programmers. They are sorted from beginner to expert:
If you can get only one book, get the The C++ Programming Language.
Even though Bruce's book is ancient he keeps it simple and is a fun easy read. Remember this is before C++98 where the language is much simpler.
You can find it online for free
Lastly, just because you can, doesn't imply you should. Use balanced C++ and you'll be fine.
For the fundamentals of "thinking in C++" as opposed to other languages I always recommend Effective C++
And I guess if you're in visual studio 12 make sure you're not doing anything in C++11 as I don't know any game studio or library using that as the standard yet even though it's an option in visual studio.
Since you're experienced, the best way to learn Java is to start coding in it. Create a simple blog in Java using basic servlet + JSP hosted in Tomcat + JDBC connection to some free database (Postgresql / H2). You will find issues along the way which you can Google around. The best thing about Java is that most questions already answered in StackOverflow. After you've done with it, go and read Effective Java then refactor your project to follow the best practice mentioned in the book. After that you can try to learn more libraries / framework eg. create a new reporting system and communicate the blog with the reporting system through JMS. Adding dependency injection using Spring and many more.
If the codebase is anywhere larger than a few tens of thousands of lines of code, a complete rewrite is absolutely out of the question. Any book that talks about working with legacy code will tell you this.
To get started, start with the small tasks. Fix code styling, make it readable without making changes. Break small pieces of functionality into classes with static methods (this makes it easier to navigate and reason about than regular functions).
If you can set up a testing suite somehow (it'll probably be easiest writing acceptance/functional/system tests than unit tests), that will give you confidence to make changes and check that everything still works.
There are good books on working with legacy code out there. Here are two off the top of my head:
> Another thing I want to know is which programming languages/tools I should read up on. In my experience I've pretty much only used Java, Git and some basic HTML/CSS and Javascript. I know this is largely dependent on which team I end up on, but I might as well read up on something in the few weeks between graduation and my start date (early July).
AFAIK, we only use Java for the Android versions of our mobile products (MyChart for mobile; and Haiku). Most of our applications use HTML/CSS/JS, though, with use of these technologies increasing as we move away from VB6.
We do not use Git; instead, we use SVN. Maybe spend an hour learning how SVN differs from Git, if you'd like. But a lot of our SVN workflows have an extra layer of automation and hand-holding on top, so realistically, a deep knowledge of SVN isn't particularly useful or necessary for most developers.
I assume you've heard we use VB6 and M. Our internal training materials for these languages is superior to anything you'll find outside Epic. Don't bother hunting through an antique books store for tomes on either of them.
If you're bored and want to learn some job-relevant stuff, consider the following:
> I guess my main concern here is that I just want to know if I should expect to be putting in 60 hour weeks.
I have never worked a 60-hour week at Epic (unless you count time spent sitting in airports / on airplanes as part of the workweek, in which case I've worked one 60-hour week). My typical week is 35-45 hours (which, granted, is on the low end; 40-50 is more typical).
I really like Working Effectively With Legacy Code.
Full rewrite in 1 go is the worst thing you can do. Doing it part by part will allow you to do it better.
Check this out of you haven't already: http://www.amazon.com/Working-Effectively-Legacy-Michael-Feathers/dp/0131177052
There's a pretty good book that touches the refactoring as learning tool subject: Working effectively with legacy code.
excellent post, thanks, it's always enlightening to get historical perspective like this
in a similar vein I recommend Deep C Secrets which is overflowing with historical anecdotes about the evolution of C and Unix systems
fair enough, I shall tell you my favorite C programming book then
deep c secrets
are you talking about this book ?
Not particular to php, this is a book about refactoring legacy code in general https://www.amazon.com/Working-Effectively-Legacy-Michael-Feathers/dp/0131177052
There are a few chapters about how to get legacy code under tests before refactoring. Some methods unfortunately cannot be applied to php (e.g. php core functions cannot be overriden), but still, I found it pretty useful overall.
> I absolutely HATE having to go through someone else's confusing uncommented code and figure out what the hell is going on so I can fix some bug. I hate having hours go by where I have nothing external to show for it, even though I have been running a mental marathon trying to figure out what the problem is with the code in front of me.
This is called "maintenance" and is what everyone has to do. If it kills you, then I think you will have a short career in this field. Learn some management skills and get your student loans paid off as soon as possible. Eat ramen and ride a bike in order to do so. If you hate maintenance and " the same boring financial application for a month straight" as much as you say, it will be a race between paying off your loans and quitting the field totally.
You aren't going to remember what you wrote 6 months ago, nor why you wrote it that way. So you are one of the people whose code you will be maintaining. Learn to write meaningful comments because the person you might be saving hours of wrestling with "why did this idiot write it this way" is going to be yourself. The company I work for produces boring financial applications and several of them have been shipping to customers every year for over 20 years. Migrating from one source control system to another almost always loses all the check-in comments, so all we have is the code and the historical changes.
There are 3 books that I think you ought to read:
Brownfield Application Development in .Net is aimed at the .NET stack, but I think is applicable to any framework.
Working Effectively with Legacy Code is about how to approach "legacy code" (whatever you're maintaining) in order to fix bugs and add new features.
The Passionate Programmer is about focusing on your career and how to make it through many of life's hurdles.
Take a look at the reading list I posted on another forum. Many of the books are about how to approach your career and other people in the field.
I've been a programmer for almost 20 years.
You should take a look at the book "Working Effectively with Legacy Code" by Michael Feathers, which is on exactly this topic. It's about ten years old at this point but still the best.
Here's an amazon link http://www.amazon.com/gp/aw/d/0131177052?pc_redir=1413174357&amp;robot_redir=1
What you're saying doesn't make sense. Amazon has had a rating/review system for a very long time. You can access them here. As you can see, the reviews are overall very good and it is probably a good idea to purchase this.
This book is a good resource for making sense of a lot of the spec. I'd read that (or something like it) and understand it thoroughly before trying to interpret the spec yourself.
Hmm, I had a very different impression: I thought that Architecture & Assembly and Networks were the two best courses in the program, that Data Structures, Algorithms, and Operating Systems would have been among the best had they been taught a little better (for the former) or were more rigorous (for the latter), and that the Software Engineering courses, along with Web Development, Databases, and Mobile/Cloud were the worst courses in the program.
For SE I, the primary problem, as I saw it, was that the information was either badly out of date, or covered in such cursory depth as to be useless. The course is heavily based upon the optional textbook, and if you actually read the textbook, you'll quickly discover that the overwhelming majority of the research being cited and presented is from prior to 1990, and hardly any of the citations are from after 2000. Likewise, the course focuses heavily on software development process models, specifically Waterfall and Extreme Programming. However, neither process is particularly popular in the 2016 job market; most organizations at least nominally use some form of Agile methodology, but generally not particularly well. In any event, the process model used by your organization will likely be something you learn on the job. Finally, the course almost completely ignores issues of coding style and writing code that can be easily understood by other developers (which is an entirely different skill than writing code which will pass a grading script), and the sections on system design and object-orientation, which should be the heart of a software engineering course, are entirely cursory. SE I is sadly a required course, but if you actually want to learn software engineering, you are far, far better served by carefully reading Robert Martin's Agile Software Development and Clean Code.
The less said about SE II, the better. That course is a disorganized mess and OSU should honestly be ashamed to charge money for it (the bulk of the course content, in terms of lecture time, consists of links to two free Udacity courses).
The trick is training as you go. Like 10-30min everyday, a morning routine before opening your emails, or something like that.
Choose an exercise (/r/dailyprogrammer or any code kata) and try resolving it during your timeboxed training session. At the end of the session, delete your code, and start again the next day.
Each time, focus on one aspect of the code : clean code, unit tests, object calisthenics, etc..
After a few times, when you can solve the problem with your eyes closed, pick a new one.
When you like what you did, put it on your github account and show it to other people (like on reddit or your lead dev etc)
Some resources :
Think like a programmer
I'm assuming you just want to learn the basic information about how computers work and the principles behind programming them, right?
In that case, I'd recommend Code by Charles Petzold
Are you looking to actually learn how to program and write code in a specific language? If so, then I'd recommend Automate the Boring Stuff with Python by Al Sweigart. It covers the basic principles of writing functions and how computer logic works, and you'll actually be able to apply it to some practical uses. And since its Python, it'll run on a lot of different platforms. If you like it, you may want to get into working with the Raspberry Pi. Javascript is another good language to start with, but as a book, I really like this one.
If you already know a bit about programming, and just want a general reference book, then Computer Science Illuminated by Dale and Lewis is pretty good.
Yes.
subprocessis a standard library (i.e. "baked in" to Python).pexpectis a separate install, but not at all painful. For my own reasons, I'm installing it the hardest possible way and it's literally 3 commands.If this is something you want to mess with, check out Automate the Boring Stuff.
Pick up the book “Automate the boring stuff”
Amazon
Free Online Version
And steal a project from there. The draw of python is you can make something useful fairly early on in the learning process.
Edit: I’de go with web scraping. Providing everyone with how to implement the shell functionality described in the book, and see what they come up with as far as a useful web scraper as your open ended requirement.
Here you go
So this is what I would consider the "Core" reading list for anyone interested in programming games. None of this is really game specific though. These are just the fundamentals you need in order to be an effective Software Engineer.
Learn about...
C++ syntax: Programming: Principles and Practice Using C++ by Bjarne Stroustrup
Software Engineering: Code Complete by Steve McConnell
C++ gems: Effective C++ by Scott Meyer
Software Teams: The Mythical Man-Month by Frederick P. Brooks Jr.
Why we love Joel: Joel on Software by Joel Spolsky
Problem Solving: The Pragmatic Programmer by Andrew Hunt
Common Code Solutions: Head First Design Patterns by Eric Freeman
Pearls!: Programming Pearls by Jon Bentley
I'll do a supplemental on this in a few days that dives into specific topics related to engine development. All of this is generic enough that it will help you regardless of what you do. You'll notice that very little here is actually language specific. Almost all of this is about the art of making software and process of working with a team. These 8 books alone will make you think about making software in a whole new way.
The Pragmatic Programmer
I should re-read for a refresher. Invaluable source of general information that can help any type of computer programmer, regardless of their language of choice.
The Pragmatic Programmer (http://www.amazon.com/Pragmatic-Programmer-Journeyman-Master/dp/020161622X). It's a great resource to help you think about your career and how working as a software developer is different from what you learn in school.
Read The Pragmatic Programmer
It is exactly what you're looking for.
You have to under the concept of uncoupling your programs and break them up into separate entities and that takes practice. This book will show you a few main guidelines to follow but without application you will not get pass that wall.
Don't want to bullshit anymore? put yourself in a position where you can't bullshit. Get a job as a webmaster, it's not very hard. Smaller non-technical companies would love to hire college kids to build an internal inventory tool or something that they can use.
I was also first a C programmer and only started learning cpp later. I have found this book to be excellent:
Accelerated Cpp book
it is intended to complete novices, which you are not. However I think it is still perfect for you because I think that it introduces Cpp the way it should be and not as a C extension. After you are comfortable with the std I would suggest you move to good practices books (effective c++ etc) and/or design patterns books
You can check out: http://ocw.mit.edu/courses/electrical-engineering-and-computer-science/
It's going to be unlikely, you would have to plan the curriculum yourself and get quality books/resources to teach you the material.
Books like http://www.amazon.com/Accelerated-C-Practical-Programming-Example/dp/020170353X
Offer a well planned introduction course into C++
[here is a fantastic book every programmer should read] (https://www.amazon.com/dp/0132350882/ref=cm_sw_r_cp_apa_kt9TAbN9RY2S3)
Most undergraduate courses offer some sort of capstone or "Software Engineering" course which takes you through some flavor of SDLC from start to finish.
There's books you can buy on this specific topic -- buttloads of them.
> I feel like each one is a patchwork monster of code given life only by the grace of sheer determination and a bit of luck.
Check out Clean Code if you haven't.
Currently reading Clean Code. Highly recommend it to any other software developers.
In addition to Code Complete 2, which, while very dense, is a compendium of wonderful coding knowledge... I recommend Clean Code by Robert C. Martin.
One of the best books on concurrency that I've ever read is definitely Java Concurrency In Practice it's (obviously) written with Java in mind, but most of the concepts map rather easily to constructs in other languages as well.
The standard for design patterns is still probably Design Patterns (colloquially "Gang of Four")... but I've heard good things about Head First Design Patterns as well, despite the really stupid cover.
Your friend is wrong. Sure, functions are for code reuse, but they should also be used to make code readable and especially to break down large chunks.
Just give your friend Clean Code by "Uncle Bob" Martin to read. It will completely change his views on code.
---
BTW: The second version of your code is way better, but why did you not go all the way? You still have the
crossHairTexturestuff in the constructor. Why did you not also stick this part in a function?As software engineer there are of several books like Clean Code and in other fields there are probably other essential books.
But your question probably aims at books that convey general knowledge - increasing specifically the capacity of intelligence is very debatable - in this case my answer is The Art Of Learning.
Clean Code is also a great book
Most things can't be classified as universally bad style.
Getters and setters are appropriate for objects that act as data structures (i.e. objects that provide efficient storage of data without other behaviour). They're not appropriate for more complex objects that provide services (such as the BankAccount example given by /u/exoticmatter).
Static methods are useful for making utility or helper methods, among other things. (For example, it would be really wasteful to create a new object every time you wanted to print to the console.) They're generally discouraged in cases where polymorphism would lead to cleaner code.
In short, form follows function. If you're looking for a more in depth discussion of code style, I recommend checking out Robert C. Martin's Clean Code.
For the love of god find someone else that teaches Java at a high school level. Go over their lesson plans with them. Figure out what types of things they are teaching through each unit. While reading Head First is a good introduction to programming Java, it isn't necessarily what you need to be teaching these kids at this point.
Is this a first programming class for most? Or is this a follow-up to an introductory class? There are a lot of variables that will influence the content and concepts that should be taught.
Finally, and please don't take offense to to this, but I find it crazy that they are having someone with NO experience in the position of introducing people to a field that can be simultaneously fun, frustrating, rewarding, difficult, etc. Again, please don't take offense, but you will not do a good job grading as you have no experience. You need time to practice identifying good and bad code yourself. For every problem out there you can probably devise hundreds of ways to successfully solve it, but only some of them will be elegant and (hopefully in a teacher's eyes) acceptable.
For the love of god take a programming class! Have someone look at code you are writing because there is no better way to learn than to do it yourself. Head Start is a decent point to learn Java. Also check out Clean Code as it will help you learn some fundamentals of what makes good code. Finally, get together with another teacher that has experience teaching this subject matter and leech as much as you can off of them. Software programming can be a fun and very lucrative career. I understand you are lazy but please don't sour kids on it or start them off on the wrong foot.
I spent a lot of time learning specific architectures and patterns that were in common usage when I first started, but the specific patterns in vogue are constantly changing. I'd recommend reading all 3 of these books at some point earlier in your career, I think a lot of the popular software design practices are based on the foundation of ideas in here and if you read them you will start to naturally make the right choices when it comes to organizing your code.
https://www.amazon.com/Pragmatic-Programmer-journey-mastery-Anniversary/dp/0135957052/ref=pd_sbs_14_t_0/142-3028760-3243861?_encoding=UTF8&amp;pd_rd_i=0135957052&amp;pd_rd_r=8877e123-b48f-4ce7-9e92-fec38cbeb54f&amp;pd_rd_w=CdI3a&amp;pd_rd_wg=arKVG&amp;pf_rd_p=5cfcfe89-300f-47d2-b1ad-a4e27203a02a&amp;pf_rd_r=9JQWC8NFNAY0GN7FAN9D&amp;psc=1&amp;refRID=9JQWC8NFNAY0GN7FAN9D
https://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670/ref=pd_sbs_14_t_2/142-3028760-3243861?_encoding=UTF8&amp;pd_rd_i=0735619670&amp;pd_rd_r=8877e123-b48f-4ce7-9e92-fec38cbeb54f&amp;pd_rd_w=CdI3a&amp;pd_rd_wg=arKVG&amp;pf_rd_p=5cfcfe89-300f-47d2-b1ad-a4e27203a02a&amp;pf_rd_r=9JQWC8NFNAY0GN7FAN9D&amp;psc=1&amp;refRID=9JQWC8NFNAY0GN7FAN9D
https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882/ref=pd_sbs_14_t_1/142-3028760-3243861?_encoding=UTF8&amp;pd_rd_i=0132350882&amp;pd_rd_r=8877e123-b48f-4ce7-9e92-fec38cbeb54f&amp;pd_rd_w=CdI3a&amp;pd_rd_wg=arKVG&amp;pf_rd_p=5cfcfe89-300f-47d2-b1ad-a4e27203a02a&amp;pf_rd_r=9JQWC8NFNAY0GN7FAN9D&amp;psc=1&amp;refRID=9JQWC8NFNAY0GN7FAN9D
Have a look at Effective Java by Joshua Bloch - Each chapter in the book consists of several “items” presented in the form of a short, standalone essay that provides specific advice, insight into Java platform subtleties, and outstanding code examples. The comprehensive descriptions and explanations for each item illuminate what to do, what not to do, and why.
::edit:: wrote Essential instead of Effective
Effective Java
Effective Java by Joshua Bloch.
Data structures and Algorithms Write code to impleement every (or even most) and you'll be well preparped.
Design and Testing here.
Programming Languages here.
Also look for an open source project that needs help and provides you with experience in one or more of these areas (or start your own). Code is always a good way of showing you know something.
10000 limit again. Reserving this comment for the Programming section:
PROGRAMMING
Gray Hat Python: Python Programming for Hackers and Reverse Engineers
Beginning Python
The Python Standard Library by Example (Developer's Library)
Shell Scripting
Shell Scripting Recipes: A Problem-Solution Approach
Linux Command Line and Shell Scripting Bible, Second Edition
Wicked Cool Shell Scripts
sed & awk (2nd Edition)
The Ruby Programming Language
Beginning Ruby: From Novice to Professional
Ruby on Rails 3 Tutorial: Learn Rails by Example
Agile Web Development with Rails
Automating Microsoft Windows Server 2008 R2 with Windows PowerShell 2.0
Pragmatic Guide to Subversion
Programming Perl
C++ Primer Plus
The AWK Programming Language thanks sjhill
Modern Perl thanks three18ti
High-Order Perl thanks three18ti
The Art of Scalability thanks mr_chip
Scalability Rules thanks mr_chip
Continuous Delivery thanks mr_chip
The Varnish Book thanks mr_chip
Ouch! Sounds like you don't have any part of a continuous delivery pipeline ready. I would start from there before doing anything else. This book covers the whole concept nicely: https://www.amazon.com/gp/aw/d/0321601912
We were in exactly the same situation year ago when I started. The production was last deployed months ago because it was so painful. Now we deploy over ten times per day and the whole 15min process is automated. Deployments have become a non-issue and there's no need for anybody to be on-call or lose their sleep because of it. :) It has also made a huge difference to our productivity and allows us to crush the competition via rapid innovation.
If you're very far already (using the language for over a year, for instance) you could try to fix the gaps by watching Going Native talks and reading A Tour of C++. If you're just starting out, I suggest either getting C++ Primer or The C++ Programming Language and working through that.
I wouldn't recommend "The C++ Programming Language" as a learning resource, though it's a great reference for once you've got a decent understanding of C++. I've tried reading that, Accelerated C++, and C++ Primer, 5th Ed., and C++ Primer was by far the most useful, and once I finished it I finally felt like I had a fairly solid grasp of the basics of C++.
https://www.amazon.com/Primer-5th-Stanley-B-Lippman/dp/0321714113
For the actual programming, there's the Juce C++ library which is pretty essential. If you spend a few minutes scouring the website, he recommends some good resources (both digital and print) for learning C++.
For DSP knowledge I would start with DSP Guide because it's just bloody incredible.
As far as books go, do you mean books on audio programming or C++? I started learning C++ with C++ Primer, but for audio programming both Designing Audio Effect Plugins In C++ and The Audio Programming Book have been invaluable.
Also check out the KVR Developer Forum!
Absolutely! You should always understand the simple features of a language before you move into more advanced measures.
This is how I first learned C++:
C++ Primer 5th Edition by Stanley B. Lippman. After years of fooling around with C++, this book took my understanding to the next level. If you have the time, read it, take notes, and try the practice questions. It is long though, but worth it if you are serious about learning the language. Might be rough for people completely new to programming though.
If you want to dig deep into the theoretical of programming, and help build a good foundation for OOP, patterns, and algorithm design, check out Concrete Mathematics: A Foundation for Computer Science. It is honestly the best textbook I have ever come across.
From there, if you're feeling really ambitious in studying algorithms, check out The Art of Computer Programming, but I should warn you, it is very dense and can be hard to understand even for accomplished developers.
Beyond that, I suggest checking out The Odin Project. It covers a variety of languages and frameworks including Ruby On Rails, which is pretty standard in app development these days. They have a lot of great references and side material. It's basically a "go at your own pace" open source coding boot-camp.
> Like I said, this is for me. I hate just being told "do this" and having no concept of why. I want to understand why I'm doing it, the implications for doing it "this way".
This... This is the mindset that will carry you and eventually make you stand out as an exceptional programmer. Learning how to do something might land you a job, but knowing how it works makes you an invaluable asset to any employer.
As long as you are passionate about learning the material, you will pick it up over time.
>This is where I realized that I was doing this wrong, at least for me. I'd be on codeabbey and know what I wanted to do, but not how. I realized that I needed to be building larger things to be working with oop concepts. I really felt I was missing a lot of "base" information.
Awesome observation. Doing studying and doing drills both have an important role in the learning process, but there are other forms of practice to include in order to reinforce the material in a meaningful way. Ruby Rogues Podcast has a great group discussion about how to learn that I highly suggest you give a listen.
Personally, I learn best by throwing myself into a project where I am in wayyy over my head. By struggling through problems, scrupulously tearing through documentation and examples, I learn a lot more of the why than the how at the end of the day.
I learned Javascript, jQuery, and AJAX by building a templating & ecommerce framework. I started out with little to no knowledge or understanding of how JS worked, and was forced to restart a number of times as I began to see what was good and what was not, but now I feel very comfortable working with it.
Find a problem, and solve it, because Computer Science is, really, just the art of problem solving.
Best of luck, and most importantly, have fun :D
The Clean Coder: A Code of Conduct for Professional Programmers https://www.amazon.com/dp/0137081073/ref=cm_sw_r_cp_api_i_6rJ6AbTS2DYWA
All the programming best practices you know apply to refactoring as well.
Use source control (Git, Mercurial, SVN, whatever) and commit often, on your own refactoring branch if possible. This way you can "save progress" and revert any changes, should your code get worse in some way.
Also, test a lot. Both during and after the refactoring. Having automated tests really helps. Make a small change, run the tests, make sure everything works, rinse and repeat.
Martin Fowler and other people have books on refactoring. I'd also recommend watching one of his talks.
Lastly, remember that refactoring is not a one-time thing. It's a frequent, ongoing process.
Make small revertible changes in one unit/module at a time, if possible. You don't want to fall too deep in the rabbit hole, and forget what you actually wanted to change.
Not Android, but, much of what konk3r said in his comment is packaged nicely and easily consumable in Refactoring by Martin Fowler. Before you begin coding Android, understand Java and what it takes to write maintainable code. Any mildly intelligent chimpanzee can write code; it takes a talented programmer to write code that others (or even the dev himself) can maintain.
Other things:
Maybe this will help.
https://www.amazon.com/Pragmatic-Programmer-Journeyman-Master/dp/020161622X
Seconding The Pragmatic Programmer and Cracking the Coding Interview. I'd also recommend:
If you let us know which languages you primarily write, I can probably recommend some good language-specific titles, too.
Pragmatic Programmer, Clean Code, and Head First Design Patterns come to mind right away. They're 3 of my favorites.
There's also Design Patterns by the Gang of Four. That's a lot more dense IMO than Head First, but it's fantastic material.
Since you're looking to jump ship and start interviewing, take a look at Cracking the Coding Interview. That will prepare you for any questions you run into during the process.
It's probably also worth brushing up on Algorithms and Data structures.
The Pragmatic Programmer: From journeyman to Master. It's a philosophical book that shares wisdom on how to think like a programmer. . . Not in the pure sense making you a better Computer Scientist (in terms of thinking algorithmically) but if you write code you should give this one a thumb through.
I can't speak of a specific book that is a comprehensive history of computing, but I will speak to books that speak of our culture, our myths, and our hero's.
Hackers and Painters, by Paul Graham. People are polarized about the man, whether he's too "pie in the sky" - full of shit and ego, or if he speaks as an ambassador to our most optimistic ideals of our (comp-sci) culture. The contents of this book is a collection of his essays that are inspirational. It made me forego the societal pressures within our culture and reject popular opinion because it is merely popular and just an opinion, which is a virtue no matter who you are, where you are, or what you do. All these essays are on his website, though. If you want to review them, I recommend Hackers and Painters (the essay), What You Can't Say, Why Nerds are Unpopular, and The Age of the Essay; his oldest essays are at the bottom of the page and go up - he writes about what he's thinking about or working on at the time, so you'll see the subject matter change over time. So much of this will have direct application to his middle school and high school life. I cannot recommend this book, and the rest of his essays, enough.
If he wants to get into programming, I recommend The Pragmatic Programmer. This book talks about the software development process. I'm not going to lie, I don't know when best to introduce this book to him. It's not a hard read whatsoever, but it's abstract. I read it in college in my first months and said, "Ok," and put it down. Approaching the end of college and my first couple years in my profession, I would reread it ever 6 months. It's a kind of book that doesn't mean anything, really, without experience, without having to live it, when he has an obligation to his craft, his profession. I tell you about this one since you're asking about books to tell him, because this isn't something someone would normally come up across without being told about it.
The Cathedral and the Bazaar is a telling book about the cultural differences between the proprietary monoliths like Apple and Microsoft, and the Free and Open Source Software communities that back such popular software as Linux (the most popular operating system on the planet, running on all top 500 super computers, most server computers on the internet, and all Android phones) and Chrome(the worlds most popular web browser). Indeed, this book directly reflects the huge cultural battle that was duked out in the field, in the industry, and in the courts from the mid-90s and into the 2000s. It advocates helping the community, contributing to something larger than yourself, and that none of us are as good as all of us. To paraphrase Linus Torvalds(inventor of Linux) "Given enough eyeballs, all bugs are shallow."
It's important to know who the hero's are in our culture, and they are diverse and varied, they're not just computer scientists, but mathematicians, physicists, philosophers, science fiction writers, and more. I would find a good book on Nicola Tesla, since he invented basically everything anyway (Thomas Edison was a great businessman, but a bit of a tosser), Richard Feynman was a physicist who is still celebrated in his field, and he even worked for Thinking Machines, back in the day, which was a marvel of it's time. Seymour Cray founded Cray Supercomputers and they have a lasting legacy in the field, a biography on that would be interesting. A biography on Symbolics and their Lisp Machines will make him yearn to find one still functioning (a rare gem that crops up every now and again, though he can run one in an emulator), and about the "AI Winter", a significant historic era (note: the AI Winter is over, and we are in spring, the history is both compelling and enthralling). Anything Issac Asimov published (in nearly every category of the dewy decimal system) is also compelling, and hardly dated. In fact, he's the originator of a lot of modern sci-fi. Charles Babbage invented the modern computer (though it was entirely mechanical in his day, and it wasn't actually built until 1996-2002) and Ada Lovelace was the worlds first computer programmer. A woman! Speaking of women, and it's worth young men learning this about our history, Grace Hopper was a military computer engineer who invented the term "bug".
And speaking of women, someone I have respect for, especially if your boy wants to get into game development is Sheri Graner Ray's Gender Inclusive Game Design, which may be more appropriate when he's in high school, and I consider it required reading for anyone who wants to enter the gaming industry. The book lays out plainly how video games hyper-sexualize both women, and, for some reason surprisingly to many - men, it's disastrous effects it has for the game industry, the game market, and the gaming community, and insights on how we may combat it. I have seen colleagues (men) become indignant and personally offended at reading this book, but were absolutely humbled when they took the fight to Sheri directly (we had a few phone interviews with her, always fantastic). If your boy found a problem with this book, he would do well to read Paul Grahams essay on keeping his identity small... The subject matter is not a personal attack on the individual, but on the blight, and he would be better served finding himself on the right side of history with this one, it would serve him well if he were to pursue this craft, specifically, but also any forward facing media in general.
And I also recommend some good books on math. Algebra, linear algebra, calculus, and statistics. You can get very far, lead an entire career unto retirement without knowing anything more than arithmetic and basic, basic algebra, but he could only serve himself well if he makes the decision that he is going to like maths and chooses to willfully become good at it. Outside the context of school and terrible teachers, it's actually an enthralling subject. Just get him a copy of Flatland, Flatterland, and Sphereland. Try this. There are books about proofs that break them down into laymen terms so that anyone can celebrate how special they are. My wife has a few on the shelf and I can't remember their titles off hand. Also this, the book is the narrative of some witty laymen who discover a whole branch of mathematics from first principles, the surreal numbers, an extension of imaginary numbers. It's really quite good, but might keep him occupied for a couple years in high school.
I should stop here or I never will.
The Pragmatic Programmer: From Journeyman to Master
It's not really focused on Java or any language specifically, but it helps you become a better team member. The concepts help you write code you won't curse at later...
The book Clean Code was recommended to me by my manager when I asked about writing more efficient code. The author goes through best conventions of naming/organizing/etc for keeping your code base super clean and legible. Other people also recommended the Pragmatic Programmer, but I haven't had time to get to it.
https://www.amazon.com/Pragmatic-Programmer-Journeyman-Master/dp/020161622X This is a book I usually advise junior developers to read. Another one is Clean Code by uncle Bob.
Here are some:
http://www.amazon.com/Test-Driven-Development-Addison-Wesley-Signature/dp/0321146530
If you haven't read these books already, what are you doing, go and read them now.
Effective C++
More Effective C++
Effective STL
Effective Modern C++
I'll start off with some titles that might not be so apparent:
Unexpected Fundamentals
These 2 books provide much needed information about making reusable patterns and objects. These are life saving things! They are not language dependent. You need to know how to do these patterns, and it shouldn't be too hard to figure out how to implement them in your chosen language.
&nbsp;
Good General book
&nbsp;
This book is great if you're going to make a browser based game
&nbsp;
General Knowledge books
&nbsp;
Provide a working moveable 3D model with C++ and DirectX, Very cool.
&nbsp;
More general game base building
&nbsp;
Working product results books, little if any modification needed
Releasing in a couple months (hopefully) 2 Very good books using C++ to develop by.
&nbsp;
Not presented in the best manner but still noteworthy:
&nbsp;
I used to love XNA...but now it's not feasible for commercial development. If you're a beginner to game design...starting out with XNA might actually be useful. It's easy to pickup and put out a working product. XNA is C#
&nbsp;
&nbsp;
Working product books, modification needed to make run on current systems
Provides a working FPS game in C++ on DirectX 9. Good for some starting out knowledge for an FPS
&nbsp;
Good for 3D Terrain rendering in DX9...however much of this is outdated...some concepts still apply, and it's not the worst idea to see a working example.
&nbsp;
TLDR: Click links starting at top, buy, read, profit
this book is often mentioned among the best programming books ever written; together with Larry Wall's (Camel) Perl book, and Dennis Richie's C book.
Effective Java
http://www.amazon.com/Effective-Java-2nd-Joshua-Bloch/dp/0321356683/ref=sr_1_1?ie=UTF8&amp;qid=1314549239&amp;sr=8-1
http://www.curious-creature.org/2008/12/18/avoid-memory-leaks-on-android/
http://www.androiddesignpatterns.com/2013/04/activitys-threads-memory-leaks.html
Less specific resources:
I vehemently disagree with the internal/getter/setter rules mentioned in android developer tips page. I personally use proguard and don't think twice about virtual setters etc. since they most definitely help with clarity
I would highly recommend reading Effective Java if you want some more advanced java topics.
I actually never considered speed when thinking about best practice, so that's an interesting thing to keep in mind as well.
But yeah, one thing I forgot to mention is that I've been reading the book Clean Code, and so far, your solution fits in much better with the conception of best practice that I've learned from that book than all of the solutions voted best practice on codewars. Like I went into codewars thinking to minimize writing lines that do more than one thing, and to try to avoid cryptic syntax as much as possible, but that's the exact opposite of what codewars has been telling me is best practice so far.
I cannot recommend Clean Code by Uncle Bob nearly enough. I learned about him from his (rather idiosyncratic) videos on the subject, and it literally changed my outlook on writing software, top to bottom.
This might seem hyperbolic, but I can't stress the value of his ideas enough - my old company had access to his videos on our internal network, and the first 5-7 videos became required watching for the entire team I worked on. It was a lot of time to devote to something that wasn't coding, but I really believe it helped even new graduates understand the ideas behind "good code" and how to make clean systems in practice.
Let me know if you have any questions about the what or why of the suggestion.
Edit: In the spirit of PM_ME_UR_PIN_NO, I would also emphasize that there is no royal road to writing perfect code, because there isn't even consensus on what perfect code is. This kind of thing is the part of what we do that is more art than science, but I have yet to see a more effective collection of useful tactics than Uncle Bob's work.
That is a lousy professor. You want to learn more? Nope, don't think so.
You could find open source projects that are written in java. Or maybe check out the source code for OpenJDK (library implementation).
But better yet, pick up a book. You have the popular book Clean Code by R. C. Martin that covers how to write clean and maintainable code. Or maybe the book Head first: Design Patterns by that covers common designs used to make adaptable and reusable code.
But your professor has one point. You should not get lost into code design when still learning the basics. So remember to focus on what you learn in class! :)
https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
I recommend the Clean Code book, it has easy examples for stuff like that.
The most important thing to me isn't that someone knows everything about a language but knows how r o code well. I highly recommend - Clean Code: A Handbook of Agile Software Craftsmanship https://www.amazon.com/dp/0132350882/ref=cm_sw_r_cp_apa_i_8wOwDbEN2SQCM
> "oh yeah, that's just how that goes. If you run those one-off they always fail. You have to run the whole suite to make it work."
REQUIRING A SPECIFIC TEST ORDERING MEANS THEY'RE NOT FUCKING UNIT TESTS... HELL, THEY'RE NOT GOOD TESTS IN GENERAL, EVEN INTEGRATION TESTS SHOULD RUN INDEPENDENTLY (BUT MIGHT TAKE LONGER)
I TRIED TO FIND A GOOD CITATION FOR THIS BUT GODDAMN, GOOD DEVELOPERS SHOULD KNOW THIS SHIT
I SUSPECT CLEAN CODE HAS THINGS TO SAY ON THIS SUBJECT, FORCE IT UPON THEIR EYEBALLS
Design Patterns by Erich Gamma , Richard Helm , Ralph Johnson , John Vlissides
https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612/ref=sr_1_3?ie=UTF8&amp;qid=1549541116&amp;sr=8-3&amp;keywords=design+patterns
Concurrency in Practice by Brian Goetz
https://www.amazon.com/Java-Concurrency-Practice-Brian-Goetz/dp/0321349601/ref=sr_1_1?ie=UTF8&amp;qid=1549541190&amp;sr=8-1&amp;keywords=concurrency+in+practice
Clean Code by Robert C Martin
https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882/ref=pd_sim_14_4?_encoding=UTF8&amp;pd_rd_i=0132350882&amp;pd_rd_r=cf3a76e3-2ad0-11e9-91c7-79eddbe046cc&amp;pd_rd_w=RVwGU&amp;pd_rd_wg=ZJ2Iq&amp;pf_rd_p=90485860-83e9-4fd9-b838-b28a9b7fda30&amp;pf_rd_r=4P48EDFQ0VNRGZYAE96S&amp;psc=1&amp;refRID=4P48EDFQ0VNRGZYAE96S
Bjarne Stroustrup - Programming: Principles and Practice Using C++
If you already know about pointers, etc
cppreference
Hey, I recommend the book Think Like a Programmer: An Introduction to Creative Problem Solving. I can't take credit for the suggestion, it was suggested by another redditor who made a great post about how to start coding when you're stuck and the problems he faced. He recommended this book, and I've been reading some of it, and it's spot-on. Easy to understand, easy to read, and will help you come up with steps on how to think systematically.
I would pick up both a data structures book and a C++ book; for instance, Data Structures and Algorithms in C++ and Programming: Principles and Practice Using C++.
Of course, you can use any data structures book you like; some are better than others, but they all teach the same stuff. But when you're learning the abstract stuff at the same time as basic programming, it can be nice to see examples in your language. Principles and Practice is one that I wholly recommend, though, as an excellent introduction to modern C++.
Also, be aware that there is way more bad C++ material out there than there is good C++ material. If in doubt, check out the semi-official book list or ask around here.
This is a very dense book, but is undoubtedly the best for learning C++ and I would argue programming in general. Just be aware, as with learning the 'vanilla' version of any programming language, you may feel dissatisfied with still not being able to do too much, and while the book does introduce GUI programming with C++ with the Fast Light Toolkit, I would suggest learning SFML or even how to use C++ within the Unreal Engine to truly motivate you.
Remember that there is no utility in learning a programming language in of itself, only in being able to actually do something with it.
I've heard good things about
Bjarne Stroustrup
Programming: Principles and Practice Using C++ (2nd Edition)
https://www.amazon.com/Programming-Principles-Practice-Using-2nd/dp/0321992784
Haven't read it, but I do have Stroustrup's more advanced "The C++ Programming Language" book and can tell you he's a great author.
+1. Videos will never do justice. Youll learn more by reading. Ive watched videos since middle school (8 years) and learned a lot of either a) outdated material or b) bad programming habits. Ive corrected all those reading books.
Save yourself the trouble and read this book if youre a beginning to learn c++ especially for the first time then read this: https://www.amazon.com/Programming-Principles-Practice-Using-2nd/dp/0321992784/ref=pd_lpo_sbs_14_t_0?_encoding=UTF8&psc=1&refRID=XFDD6E58W0CWE1K404XZ
tldr if you want to learn cpp, get a book. This one is good. Don't attempt to dive into programming with Cpp in unreal, learn cpp first then go into unreal. or just go with unity. Books are your friend.
As far as Duckett goes...his work's great, and it's good to see it being used. I'd recommend updating the students to the 2014 edition, though: http://www.amazon.com/Web-Design-HTML-JavaScript-jQuery/dp/1118907442/ref=la_B001IR3Q7I_1_3?s=books&amp;ie=UTF8&amp;qid=1411140026&amp;sr=1-3 . Also, add his Javascript / jQuery book.
Also, check out this article: Bibliographic: The 100 Best Design Books of the Past 100 Years
Depending on what you want to learn:
PYTHON SPECIFIC
You mentioned building websites, so check out the flask mega tutorial. It might be a bit early to take on a project like this after only a month, but you've got time and learning-by-doing is good. This'll teach you to build a twitter clone using python, so you'll see databases, project structure, user logons etc. Plus he's got a book version, which contains much of the same info, but is good for when you can't be at a computer.
The python cookbook is fantastic for getting things done; gives short solutions to common problems / tasks. (How do I read lines from a csv file? How do I parse a file that's too big to fit in memory? How do I create a simple TCP server?). Solutions are concise and readable so you don't have to wade through loads of irrelevant stuff.
A little while down the road if you feel like going deep, fluent python will give you a deeper understanding of python than many people you'll encounter at Uni when you're out.
WEB DEV
If you want to go more into web dev, you'll also need to know some HTML, CSS and Javascript. Duckett's books don't go too in depth, but they're beautiful, a nice introduction, and a handy reference. Once you've got some JS, Secrets of the javascript ninja will give you a real appreciation of the deeper aspects of JS.
MACHINE LEARNING
In one of your comments you mentioned machine learning.
These aren't language specific programming books, and this isn't my specialty, but:
Fundamentals of Machine Learning for Predictive data analytics is a great introduction to the entire process, based upon CRISP-DM. Not much of a maths background required. This was the textbook used for my uni's first data analytics module. Highly recommended.
If you like you some maths, Flach will give you a stronger theoretical understanding, but personally I'd leave that until later.
Good luck and keep busy; you've got plenty to learn!
I hate to sound like a dick, but go hire a programmer or read a couple books. This is /r/learnjavascript, not /r/domyworkforfree
Hang in there. The logical progression I recommend to newbies is
These two books are great for getting started with HTML/CSS/JS for non-programming people.
Obviously this drawn out approach doesn't quite work if you're on a deadline or if you're trying to learn these skills to get a job as quickly as possible, but if you've got time, take it slow and gain proficiency with each of them as you go instead of trying to dive into multiple at a time.
Sure!
Also, two other recommendations: either drill or build pet projects out of personal curiosity. Try to write code as often as you can. I block out time three times a week to write code for small pet projects. Coding drills aren't really my thing, but they help a lot of other people.
Thanks for the review. Your high esteem of it concurs with its #1 recommendation on the C++ FAQ.
Here is the US Amazon link for the book:
http://www.amazon.com/Primer-5th-Edition-Stanley-Lippman/dp/0321714113
I wouldn't recommend any websites for C++ because most tutorial authors seem to be stuck in the 90s. Take a look at some good books.
A Tour of C++ is pretty short but gives you a good overview over the language and some STL-features.
Scott Meyers wrote some books about best practices.
If you have a bit more time to spend: C++ Primer 5th edition explains pretty much everything (except concurrency). I read the book (took me a month) and was then able to write solid C++11 code.
You want this if you want the most complete set available. You can also just get volumes 1-3 and wait until all of volume 4 is done. (Hopefully Knuth will get to finish volumes 4 and 5)
Knuth has your back
Per testare le acque velocemente puoi usare https://rubymonk.com/ (introduce Ruby in modo basico). Anche Coursera, Khan, Udacity e simili hanno corsi introduttivi sulla programmazione.
Mentre se vuoi imparare a programmare, il percorso deve toccare almeno tutte queste tappe, in ordine:
Organization-Design-Fourth-Edition/dp/0123744938)
Da qui puoi partire e specializzarti in quello che ti interessa
I haven't been in or done a junior dev interview in a long time so I can't speak to whether most companies ask algorithm questions these days.
What I can say is that many of the mid- and senior-level interviews I've been in do. This means, to me at least, that you should learn this stuff even if you don't get asked it in a junior dev interview.
As as self-taught developer, you have shown that you've got the drive and curiosity to learn a lot of stuff enough to do useful work. That says something. So bravo!
Practicing is a great idea. However, if you're constantly looking at the hints before coming up with your own answer, that's probably not as helpful. It sounds like you should learn more about algorithms as a whole topic.
To shore up your weaknesses with algorithms I'll suggest a few resources that I've come across over the years. Since I went the traditional CS degree route, I haven't used these personally but I know many people who recommend them:
You may be interested in reading Incompleteness, and then consider how if we can convert Scripture to a formal system, we must have either an inconsistent one, or an incomplete one. The first is clearly false, but the second destroys Sola Scriptura.
Oh, and snide response: yes.
Study design patterns and read books by the masters.. Find the books that are recognized by the community as "the best". For example "Effective Java" is one of the best books on writing Java beyond the basics.
The Pragmatic Programmer: From Journeyman to Master
http://www.amazon.com/Pragmatic-Programmer-Journeyman-Master/dp/020161622X/ref=sr_1_1?s=books&amp;ie=UTF8&amp;qid=1374154408&amp;sr=1-1&amp;keywords=pragmatic+programmer
Design Patterns
http://www.amazon.com/Design-Patterns-Elements-Object-Oriented-ebook/dp/B000SEIBB8
http://www.amazon.com/gp/product/020161586X/ref=oh_details_o05_s00_i00?ie=UTF8&amp;psc=1
Pragmatic Programmer
You can read The Pragmatic Programmer
It's a great book about best practices of software development. And you don't need computer while reading it - it's not about code :)
> In other disciplines, engineering in particular, there > exist treatises on architecture. This is not the current case in software,
Gee I better throw out all those books on architecture since clearly they don't exist.
We can also ignore Fowler's book, GOF, SICP, and TAOCP since clearly they are treatises on software either.
Accelerated C++ by Koenig & Moo is a very good book that'll get you up to speed in no time.
I think the first confusion here is that the language is a entity in the construction of a program. Does the type of a house that is built depend on what type of hammer the carpenter used to put up the walls? Or what kind of wrench a plumber used to put together the piping? Sure, the carpenter or plumber could've used a crowbar to do their job, but was it the right tool for the right job?
The right tool to build an Android app is Java. If you need better performance, and you don't need Google APIs, you can include C or C++ to further improve performance at the cost of added complexity.
There are a lot of different abstractions to add the ability to use other languages on the platform, but this comes at the cost of performance, and added potential points of failure (more abstractions = more potential bugs not caused by the coder.)
Heavy number crunching (especially on a RISC architecture) may push the device to its limits. Do yourself a favor and learn how to use the right tool for the right job. This book is both entertaining and informative, and this book will get you started in on C++ in a short amount of time.
C++ is the inspiration for Java, and the creation of Java is what caused C# into being. As such, the syntax for all of these languages are tightly woven between each other. I wouldn't doubt that within 15 minutes of light reading on Java you'll be up and running in its entirety.
C++, while being a slightly more complicated beast, isn't inherently an overly complicated one. The Object-Oriented concepts are all there to be leveraged.
While you say you're not a professional programmer; I think you'll find that broadening the languages you do learn will improve your ability to convey your thoughts and concisely implement them.
Best of luck!
I'd reccomend Accelerated C++
http://www.amazon.com/Accelerated-Practical-Programming-Example-Depth/dp/020170353X/ref=sr_1_1?ie=UTF8&amp;s=books&amp;qid=1240536555&amp;sr=8-1
There's a [book] (http://www.amazon.com/Test-Driven-Development-By-Example/dp/0321146530/).
It's a "classic" but I personally found it on the slow/pedantic side. See if you can borrow it from someone or find a chapter online for free before you buy it.
edit - formatting
We assign mentors (usually the more experienced team members, but can vary depending on project and resourcing requirements) to new guys who will help them get to grips with things like our methodologies, coding standards, etc.
If we end up with a team consisting of a lot of guys without TDD experience (rare, but my teams can vary depending on other projects/resources within my company), we'll occasionally run TDD workshops where one of my senior guys or myself will go through a fill worked example of TDD, and then point the new guys in the direction of suitable resources so they can self learn (although we support them as much as required).
In terms of resources, there are a number of books we have on our internal "recommended reading" list:
There's a lot of information on the web, but I find sometimes books are just the best source.
The best possible book I can advise is "Test-Driven Development" by Kent Beck. Amazon link for reference :
http://www.amazon.com/Test-Driven-Development-Kent-Beck/dp/0321146530/
It's well written and introduces one to TDD in a really cool, systematic way with real-life (or real-life inspired) examples.
This is probably a better question for /r/cscareerquestions.
I'd also recommend reading through Working with Legacy Code -- you can find a decent summary of it here.
What else is there? git history, hopefully clean w/consistent branch/merges and commit messages, server logs w/devop notes (esp. heap, maxInline, GC etc params) annotated stacktrace or profiler runs, breakpoints/debug strategy, db schema, net logs, design docs yadda yadda. Not knowing anything else, i would read thru repo's recent and early history, run unit tests, profile/load test it and see how failure prone the server(s) are
You could start with an old repo that has the basic functionality you're interested in, hopefully it's a lot less LoC.
You could read Fowler or Feathers which i remember being good: http://www.amazon.com/Refactoring-Improving-Design-Existing-Code/dp/0201485672/
http://www.amazon.com/Working-Effectively-Legacy-Michael-Feathers/dp/0131177052/
If it's a web application try putting a Haskell process in front of it. The Haskell process can run the legacy server in a sub-process, holding a lock if necessary, while it proxies requests straight through to the legacy application. Write all of your tests against the Haskell code and build a good layer of unit and integration tests. As you gain confidence in the test suite slowly replace code paths into the legacy code with a Haskell module that does the same thing. Wash, rinse, repeat.
The benefit to this is that the legacy code gets under test and becomes maintainable. You can start a re-write of the code base while shipping new features. If your team wants to back out of Haskell they haven't lost anything. And if your team enjoys working with Haskell it can really improve morale.
https://www.amazon.ca/Working-Effectively-Legacy-Michael-Feathers/dp/0131177052 has plenty of good strategies for dealing with the situation you're in.
Maybe down the road your team will start to see the benefits of Haskell but I would focus on being pragmatic. I have received better results by showing people how I've used Haskell to solve problems rather than telling them why they should be using Haskell. Even if the people in your audience are skeptical they should at least see that you're getting some value out of it. That can be a compelling enough story to get them interested.
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
Junior Software Engineer Reading List
Read This First
Fundementals
Understanding Professional Software Environments
Mentality
History
Mid Level Software Engineer Reading List
Read This First
Fundementals
Software Design
Software Engineering Skill Sets
Databases
User Experience
Mentality
History
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.
I'll be honest with you, I don't think Head First Java would be a good choice, however DO READ Clean Code. I also suggest Design Patterns: Elements of Reusable Object-Oriented Software and Working Effectively with Legacy Code. The first is a classic MUST READ for anyone in software development. It present numerous challenges that most of us will face when developing solutions, and gives you the design patterns you will need to solve them. The second is great for learning how to fix your predecessors shitty code, you'll need this one. If you haven't already, look up Bob Buzzard and Andy Fawcett. These two guys are my favorite SFDC Dev Bloggers. I also suggest watching any Salesforce Webinar that has anything to do with code, especially security stuff.
Practice makes perfect, except for us there is no perfect, just better. Know your best practices and live by them. With everything you do ask how can I make it better? Faster? More efficient? Do I even need code, or will Workflow/Process Builder/Flow do? How can I write code, so that an Admin can customize it without any code?
> Based on code reviews--my code is pretty good, with good logic and pretty well laid out.
This is actually VERY important, having good logic is obviously crucial, but being well laid out is a kind of hidden requirement with code. You or somebody else will eventually need to maintain your code, if it's laid out well it should hopefully be easy to read and maintain.
When you write code do your best to incorporate declarative features so that further customization can be done without code (I know I said this earlier, but I think it's important). Need to write some code that uses an arbitrary set of fields, consider using Field Sets. An Admin can add/remove them without code. Maybe use a Custom Setting, or Custom Metadata to map fields to values.
Learn how to use Describe calls for everything. Need to write some code that catches dupes and merges them? Don't hard code the values, then nobody will be able to remove or add fields without updating code. Instead use Describe calls, now you get every field on the object forever. Need to remove a field from an object no problem. Need to add a field to an object no problem. Does your losing record have child records that need to be reparented? Don't hard code, use Describe calls to get all sObjects with a Child Relationship. Use Describe to find out if it can be directly reparented or if it needs to be clones (CampaignMembers can't reparent a LeadId to a new Lead. You MUST clone and add the new Lead Id).
How much do you know about HTML? CSS? JavaScript? JQuery? Visualforce? Learn 'em. Lightning is coming, and these are going to be more important than ever (except maybe Jquery).
Practice, practice, practice. One coding assignment per month isn't that bad, but if you get some work done early and you have an hour or two to spare, work on a side project. Can you think of something in your company that could be automated, spin up a Dev Org and give it a shot. Maybe your Sales people could use a new VF page for entering information just a little quicker.
Always seek to improve your code. Always seek new ideas and better ways of doing things.
Trailhead is good, do all the coding ones you can find, it's more practice!
michael feathers, working effectively with legacy code is the bible.
Craig Russell talks about this in his latest lesson on Caster.IO - https://caster.io/lessons/mockito-what-makes-a-good-unit-test/
TLDR; If you don't set yourself up properly in a statically typed language like Java you can be in for a world of hurt when you try to test in isolation. There are ways to get there, and if you're in one of those "Oh my god, this thing is impossible to test" situations go pick up a copy of Michael Feathers book - "Working Effectively with Legacy Code". That book will walk you through what you need to do.
Still not convinced? Just look at the chapter names in the book. That was enough to sell me on it over a decade ago when I first bought it. I still have it as one of my most highly recommended books out there. It's that good.
https://www.amazon.es/gp/product/0131177052/
https://www.amazon.com/Expert-Programming-Peter-van-Linden/dp/0131774298
Expert C Programming
Right. But don't be so quick to judge. =)
The issue is that there isn't anything much better out there. A lot of the issues with teaching C is C itself.
C it a very simple language, maybe too simple. A lot of the safety in C is difficult because C doesn't give you anything to get that right. The solution to this is being very good at it, know what you're doing and avoid the problems. Modularity barely is possible in C (it is only through simple means). Dynamicity is a pain. All of these things that other languages simply support out of the box, you have to go through major hops in C so you get them.
From what I understand, most uses of C today only exist when nothing else is applicable. That is, when they really need the sort of benefits you get from using C, because the language itself isn't that great.
You could write whole books on getting modularity right in C, on getting dynamicity right in C, on getting security right in C, and so forth. And in fact there are:
It goes on and on and on. The C standard library is extremely thin (in comparison to everything out there). How can K&R2 teach you how to write highly sophisticated programs if the most advanced stuff in the standard library is sorting? I'm being a bit simplistic in this argument, but it's not so much distant from the truth.
This doesn't sound like 'advanced C', this just sounds like having low level knowledge of certain things. You'll probably have better luck searching for books on kernel development if you want to know about the linux kernel for example, or compiler dev for compiler dev, or machine learning for machine learning etc.
Doesn't get much simpler than C, past the basics programming better C just involves expanding your mental model of the cpu - i.e. understanding that memory isn't just RAM, but also your CPU has caches helps when optimising code.
That being said, I picked up this from the library and read the first couple chapters. Seemed quite good, and gave you a nice overview of some of the idiosyncracies of C! https://www.amazon.co.uk/d/Books/Expert-C-Programming-Peter-van-Linden/0131774298
> Most of my side projects end up as spaghetti failures... and my track record is full of buggy, abandoned projects.
I second what /u/Razur said. Take one of these and focus on re-implementing it well. If you've not read Clean Code, do that. Then follow those habits in taking one of your old side projects and re-implementing or re-factoring it.
Also, it is helpful to read others people's well-written code to get an idea of how to do things well. The fee Book 500 lines or less was specifically written with this in mind.
Also, if you're doing stuff in python, the book Test Driven Web Development with Python is a good book to work through.
I'm in the same boat as you but decided to go through code academy all the same. They make you start on basic HTML/CSS which I would argue anyone interested in coding should know. My only problem with the academy is that while they are the premiere place to learn syntax they don't always present the problem solving /analytical mindset you need. I recommend combing academy w/ this book and watching videos on the YT channel "crash course" about computer science and algorithms (find more in depth vids on anything that interests you). I'm still a beginner and most the people on this sub know a great deal more than I, but this is my current learning structure so I though I would share.
Thanks for linking this, I hadn't seen it yet. As a Windows admin looking to get into Linux, this seems interesting.
Also, for your automation, I'd recommend Automate the Boring Stuff with Python, if you haven't read it already. It can also be found for free here: Automate the Boring Stuff.
I'll add another plug for The Practice of System and Network Information, even if you have a good feel for the philosophical part of the job.
A lot of people like Python as it is close to english. I like this book. For this kind of task you could also use Bash and just wget the archive they post once a week.
If you're into java, I can't help but recommend Effective Java
This book is what took me from Java beginner to closer to Expert. It's full of best practices, tips, tricks, and guidelines. I try to re-read it once a year. Sorry if my praise sounds hyperbolic but it's the truth.
For testing, I liked this one: https://www.amazon.com/Growing-Object-Oriented-Software-Guided-Tests/dp/0321503627
For version control, continuous integration, continuous delivery, this was a good read: https://www.amazon.com/Continuous-Delivery-Deployment-Automation-Addison-Wesley/dp/0321601912
There are many extreme programming books that briefly talk about pair programming. If you want a book specifically on pair programming only then there is this: https://www.amazon.com/Pair-Programming-Illuminated-Laurie-Williams/dp/0201745763
There are thousands of books out there for learning various topics of software engineering.
Hello and welcome to the club! To answer some of your questions:
Books. The aforementioned The Phoenix Project and The DevOps Handbook are both great resources that will help you understand what devops aims to do. The handbook has a lot of great "what am i doing (and why am i doing it)" explanations and practical implementation advice. I would add Continuous Delivery to the list as well. Because it lacks the Goldratt-inspired language of The DevOps Handbook it's a little more to-the-point regarding "what am i doing (and why am i doing it)" imo and easier to read and understand in one pass if you're looking to dive in quickly.
We don't know what what your company produces or the exact scope of resources you manage, but AWS is a big, robust ecosystem, and it's a great place to get started with devops. Don't be too worried about limiting yourself. After all, AWS is the biggest cloud platform provider in the world right now; it's a really big pigeonhole to land in. Any patterns you apply to AWS can very likely be translated to other cloud providers.
> Lastly, what are your thoughts on devops vs software engineering?
Software engineering is the "dev" in "devops". Unfortunately a lot of companies hire "devops engineers", but really they expect very little "dev" and a lot of "ops". Developing apps and infrastructure together is great way to optimize your stack and deployments. It's the quintessential devops move. Take advantage!
Agile Testing: A Practical Guide
Continuous Delivery
Clean Code
Obviously, after this you can expand more in the direction of your particular product needs. I've been doing a lot of reading around CI/CD process, and the overall trend towards "DevOps". But you might want to focus on security or performance testing, and that will have its own path.
It stands for Continuous Integration Continuous Delivery. To plug /u/KevMar's own blog he did a good write up on setting up a CICD pipeline for PowerShell modules. I also threw in 3 other links to some of my favorite blog posts on it.
You'll see a bit of variation from each post, which is nice because you can get an idea of the general theory behind CICD and see early on that the tools involved can change quite a bit.
A book my team at work lives and dies by is "Continuous Delivery: Reliable Software Releases through Build, Test, and Deployment Automation". It's an amazing read, and my recommendation for anyone interested in the practices of CICD!
https://www.amazon.com/Continuous-Delivery-Deployment-Automation-Addison-Wesley/dp/0321601912
Self-taught software engineer checking in to add on to this.
Everything u/TOM_BRADYS_PET_GOAT said is true.
I'll add a few specific resources:
Computer science fundamentals are really scary and overwhelming if you're self-taught. I'd highly recommend reading The Imposter's Handbook to get started with this topic. You'll want more in-depth material afterwards on each of the various subtopics, but this book is absolutely fantastic as a (surprisingly deep) introduction to all the concepts that's framed specifically to get self-taught programmers up to speed.
After you're familiar with the concepts at a conceptual level, and it's time to just get down to dedicated practice, Cracking the Coding Interview will be an invaluable resource. This book exists for the sole purpose of helping people become better at the types of questions most commonly asked during coding interviews. It's not just a list of a bunch of questions with solutions, it actually explains the theory in-depth, provides drill and smaller practice questions, as well as questions designed to emulate specific interview scenarios at real tech companies like Google, Microsoft, Amazon, etc. It'll even talk about the interview process at those companies outside of just the questions and theory behind them.
As a more general resource that you'll reach for repeatedly throughout your career, I'd recommend The Complete Software Developer's Career Guide. This book covers everything. How to learn, how to interview, how to negotiate salary, how to ask for raises, how to network, how to speak at conferences and prepare talks, how to build your personal brand, how to go into business for yourself if you want, etc. and that's just scratching the surface of what's covered in that book. I did't even buy this book until I was 10 years into my career and it's still very insightful.
And lets not forget, being a good developer isn't just a matter of making things that work, it's a matter of writing code that readable, extensible, and a pleasure for other developers to work on. So to this end, I'd recommend any developer read both Clean Code and Clean Architecture: A Craftsman's Guide to Software Structure and Design
OK, I'm surprised that I'm the first to mention this. First, about some of the answers already given, as mentioned in Clean Code,
>You also don’t need to prefix member variables with m anymore. Your classes and functions should be small enough that you don’t need them.
I think it is better to not use convention such as `m
prefixes because this make your code less noisy, hence putting the emphasis on what you truly want to communicate. Of course, if doing this is a convention in the project you are working on, well, do it. It's probably not worth loosing your time fighting over this convention.<br /> <br /> Moreover, the idiom<br /> <br /> Foo::Foo(int fooCount): fooCount(fooCount)<br /> {}<br /> <br /> is perfectly OK. You can find a lot of references where people do this. However, as almost every rules, you cannot apply it blindly. For instance,<br /> <br /> Foo::Foo(std::vector&lt;int&gt; fooCounts): fooCounts(std::move(fooCounts)) {<br /> assert(fooCounts.size() &gt; 0);<br /> }<br /> <br /> is a bug. There are two ways to solve it,<br /> <br /> Foo::Foo(std::vector&lt;int&gt; fooCounts): fooCounts(std::move(fooCounts)) {<br /> assert(this-&gt;fooCounts.size() &gt; 0);<br /> }<br /> <br /> and<br /> <br /> Foo::Foo(std::vector&lt;int&gt; fooCountsRhs): fooCounts(std::move(fooCountsRhs)) {<br /> assert(fooCounts.size() &gt; 0);<br /> }<br /> <br /> <br /> I prefer the later, since it give the best result when you generalize it to setter, i.e.<br /> <br /> Foo&amp; Foo::setFooCounts(std::vector&lt;int&gt; rhs) {<br /> fooCounts = std::move(rhs);<br /> return *this;<br /> }<br /> <br /> has the signatureFoo& Foo::setFooCounts(std::vector<int> rhs)which is less noisy thanFoo& Foo::setFooCounts(std::vector<int> fooCounts)wherefooCounts` is repeated twice on the same line.In summary, the goal when you code is to communicate your intention in the best way you can, which implies giving enough, but not too much, details. In particular, you do not want to repeat yourself or to give information which is made obvious by the context.
A lot of these are known as "Code Smells". Learn to identify them and try to fix them.
Other good books that may help you:
Use something like StyleCop or Linting which are supposed to check and compare your code against best practices.
i’m sorry for this situation, a lot of others answered this question very well. i just want to add that there’s a book called The Clean Coder that talks about this side of being a software engineer, I’ve personally found it an excellent and relevant read that sheds a lot of light onto this side of the job
https://www.amazon.com/Clean-Coder-Conduct-Professional-Programmers/dp/0137081073/ref=mp_s_a_1_1?crid=3JNY7TQSIG54Y&amp;keywords=the+clean+coder&amp;qid=1555869433&amp;s=gateway&amp;sprefix=the+clean+coder&amp;sr=8-1
Comments lie, code does not. If you can't name your classes, methods and variables in a way that I know what you are doing, then I'm not going to approve your pull request.
Also, if the pr comes from a junior dev or new hire, I will buy them a copy of this book:
https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882/ref=pd_lpo_sbs_14_img_0?_encoding=UTF8&amp;psc=1&amp;refRID=2GRKWCXC0MEEKXJN49HK
which explains, rather eloquently, why comments are not a good thing.
(caveat: rarely, there needs to be a "why I did this" comment, and that's OK. That's not what I am talking about.)
Personally I'd say it's not about just fixing bugs, but learning to set your code up so that it is easily readable and bugs are easily identifiable. SOLID principles are principles to live by, all of my coworkers recommended the following book by Uncle Bob: https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
SOLID concepts aren't easy to grasp especially at first, I am still greatly in the dark on most of it to be honest. But just the few skills and practices like Dependency Inversion and SRP are already making my software easier to maintain and modify
Code is clean if as many as possible of the following points are true:
To me this is about as clean as it can get:
https://golang.org/src/net/http/server.go
Although even here some functions are quite long and some comments are superfluous.
I'll preface this by saying i've done a little bit of hiring and helped my boss look at candidates so i'll try to explain why interviews might not be coming your way.
Also be wary that i'm bias. I don't really understand the idea of a "boot camp"; You can't leave your job and become a teacher or a lawyer in 6 months, why is a developer different? I guess it just seems a bit offensive to just assume that the field has such a lower barrier to entry that you need next to no training to be work ready.
Ok rant over.
Some tips/advice:
Portfolio critique:
Clean code.
This 100 times over.
The only way to really learn programming is to pay with it in sweat and frustration. If you can hack together a little project. You just learned a lot.
if you try to maintain that project that you just hacked together. You'll learn even more (and why every choice you originally made was bad).
When you're just starting out don't focus necessarily on writing the perfect, best code every time. As "Uncle Bob" Martin says "In order to write clean code, you must first write dirty code - then clean it"
Step one: Get your hands dirty...(and try out a project)
What you are missing is reading this.
There are many books that you can get for programming. However I would like to recommend particular one because despite really known a lot around good programmers it is not really known by beginners. Much as writing a code writing good and clean code is important too. It would allow you to have good fundamentals regarding structuring your code which would help maintenance and readability.
https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882/ref=mp_s_a_1_2?ie=UTF8&amp;qid=1550162739&amp;sr=8-2&amp;pi=AC_SX236_SY340_FMwebp_QL65&amp;keywords=clean+code&amp;dpPl=1&amp;dpID=515iEcDr1GL&amp;ref=plSrch
They are older books, but really changed my way of programming. Refactoring by Fowler and Test Driven Development by Beck.
https://www.amazon.com/Refactoring-Improving-Design-Existing-Code/dp/0201485672
https://www.amazon.com/Test-Driven-Development-Kent-Beck/dp/0321146530
Feeling overwhelmed and confused can always be solved by breaking things into small enough problems and making enough tests to make sure that your assumptions match reality.
Frameworks can be confusing the way they hide details away from you. Remember though, that with open source, there is nothing to stop you from digging into the framework methods you are calling and see how they work. If you get stuck, sometimes looking at the source will tell you more than looking at the docs. Try multiple frameworks in multiple languages. Once you think you have an idea of the different parts required, try using a template library and an ORM library and write the rest of the code you need to make a basic custom framework.
If you want to see a more direct approach to web services, take a look at Go, where frameworks are almost discouraged. http://thenewstack.io/make-a-restful-json-api-go/
I have included some links for more information about myself in the original post.
To have a better idea of the type of person I am these are the books within my arms reach right now:
Design Patterns: Elements of Reusable Object-Oriented Software
[Refactoring: Improving the Design of Existing Code](
http://www.amazon.ca/gp/product/0201485672)
The Mythical Man-Month
Along with some other ~50 similar books I've read.
It's going to be hard, make no mistake about it. Most places won't want to interview you just based on the fact that you haven't worked for 10 years after graduating. There's going to be some level of disappointment and you'll need to be ready for it.
If your knowledge of C++ comes from school, it's likely at a basic level. Improving on C++ is generally harder than just learning .Net, Java or python.
But if you do feel comfortable with C++, I would suggest getting a more advanced level book rather than relying on online tutorials. My favorite one is Effective C++ from Scott Meyers. Try finding a used version to save money.
You will also need to meet recruiters and be confident but open with them. This is a trial and error with a low hit rate but I would suggest doing it anyway.
You could also sign up for a coursera or udemy course on web development and start creating a project. Make sure you get a github account to showcase your web development skills to any potential employer.
I just looked through all my books. It's actually hard to find a book with large segments of good code. This is probably the worst book when it comes to good c++:
http://www.amazon.com/Numerical-Recipes-The-Scientific-Computing/dp/0521750334/ref=pd_sim_sbs_b_15
The best is probably scott meyer's effective c++. It gives small sections of good code and all 55 tips are gold (or silver)
http://www.amazon.com/dp/0321334876/ref=rdr_ext_tmb
I just resently started a carreer as a Java Developer myself (m/22), so I can remember the things I had a hard time with like it was yesterday.
What I had the most trouble with, carreer wise, is the configuration of a lot of frameworks. Java in itself is relatively easy (especially since you already are an experienced developer), it's the frameworks that require the most time to learn. A lot of them require a certain amount of configuration, mostly in XML. Learning how to set them up was mostly trial and error in my case. Like someone else said in the comments, pet projects are the best way to learn this. So, to answer your question about what I hate about Java: this configuring is it. Stuff like that is easier in, say, C#. However, if you join an already existing project, the configuration is already done most of the time (although not always very good).
Now for the resources. I really did a bad job with Java in my first year of college, but this guy really helped me with his tutorials (I got 100% percent when I took the exam again): [The New Boston] (https://www.youtube.com/playlist?list=PLFE2CE09D83EE3E28). I linked you the beginner tutorials, but he also has intermediate. [Effective Java] (http://www.amazon.com/Effective-Java-Edition-Joshua-Bloch/dp/0321356683) is also a good resource, like mentioned in the comments. Another one I like is [The Well-Grounded Java Developer] (http://www.manning.com/evans/). It is a really balanced book, talking about important things like Threading, the JVM, Dependency Injection, Continuous integration etc.
I would suggest you first do some little projects to get a feeling with Java as a language, and then stepping over to frameworks like Spring and hibernate. Check the differences between Spring and Java EE, read about dependency injection (Martin Fowler has a great article about this), etc.
This turned out longer than I expected, so I'll leave it at this. If you still have questions, feel free to PM me or leave a comment.
Effective Java
This Book. Read it. It's fantastic
Also Effective C++, because it's full of gotchas and important but subtle language features that are ideal for interview questions. A lot of it will be too advanced for a jr. level interview, but you should read it anyway because it's a great book.
Effective C++
There's OO design, and there's particulars as to how to implement things in C++. I'm totally with unapersson as to, that the Os you make are as often conveniences or design helpers as representing real world objects. Ie that it's implementation objects. I don't remember how much OO design advice Effective C++ has, but it's a good book to get someone to intermediate C++ programmer. C++ Coding Standards by Herb Sutter and Andrei Alexandrescu talks at a fast clip about a lot of taste and design issues; I haven't looked at the 3rd edition of Eff. C++ but, from earlier editions, the difference is that Coding Standards is more dense, and sophisticated; Eff. C++ more basic (from what I can see, Coding Standards does cover the same material as Eff C++, but in a very compressed form, only the most minimal discussion; maybe not what you want when you're seeing the material for the first time.
As for pure OO design, I've heard that straight-up Grady Booch is still the best, but I have no experience of it.
I will say, if you want to be good at C++, you'll have to spend money on books (but get your company to buy them perhaps - compared to programmer time, books are free), and time on reading them; there are a lot of best-practices, technicalities and real pitfalls that are not immediately obvious.
edit:
> Also, should I be studying data structures/algorithms in unison with OOP?
Definitely. Have you learned the basics, stack, tree, queue, hash tables (or set, map, vector, unordered_set, unordered_map)? You /must/ know these. (priority_queue and list too, less so maybe.) If you can though I'd read (somehow) about other data structures, spatial ones especially in your case; they can really make your program more efficient and thus able to do more.
edit edit:
I have to say, the above books are for long-lasting code; probably for games your best bet is to look at how other programmers write their games (smaller, simpler, even in other languages - it can be hard to understand large, sophisticated codebases) and, just the necessary experience you gain from writing your own.
if you have yet to, read THIS book!
Many C++ interview questions are lifted right out of here, and for good reason. It contains so many pitfalls and good habits.
These are books I read many years ago, they can be helpful but may be dated and will not include newer features. But as an introduction they worked well.
Thinking in C++ Voume 1 and 2 by Bruce Eckel
https://www.amazon.com/Thinking-Vol-Introduction-Standard-2nd/dp/0139798099/ref=dp_ob_title_bk
https://www.amazon.com/Thinking-C-2-Practical-Programming/dp/0130353132/ref=pd_sbs_14_1
And Scott Meyers
Effective C++ - https://www.amazon.com/Effective-Specific-Improve-Programs-Designs/dp/0321334876/ref=pd_sbs_14_2
Effective STL - https://www.amazon.com/Effective-STL-Specific-Standard-Template/dp/0201749629
C++ isn't that hard, unless you're trying to learn all of it. When I deal with unfamiliar (complex) APIs, part of the struggle is learning what I can ignore--what pointer parameters should usually be NULL, for example, or what typedef/macro is really just a char or int.
Another thing that used to confuse me is that some APIs want the address of a function as a parameter, while others want an object that performs a function (usually, it's because the object has operator()() defined). This is used when the API you're using assumes your function will want to remember state in a more sophisticated manner than is possible with a simple function (and the object is kept alive and its operator()() is called several times). If you really want to understand C++ (I'm not sure you do), I'd recommend Scott Meyers' Effective C++.
Sorry that I don't have any great advice, but these are a couple things that I struggled with when learning new APIs.
C++ is a complicated, technical language. I'd recommend hitting the books for it. Learning C++ properly will teach you a lot about almost any language.
Accelerated C++ is the place to start if you don't know how any of the syntax works (pointers, const, templates, etc). Read a bit of it and write some C++.
When you've written some files and feel comfortable in C++'s syntax, read Effective C++. It will teach you good practice with many points from it transferring over to other languages.
Python seconded. Learning multiple languages, especially ones that differ significantly from the ones you already know, is one of the keys to being a good programmer. This is some of the advice in Peter Norvig's Teach Yourself Programming in Ten Years.
How to think like a computer scientist is an OK introduction to Python and programming, but it's very undeserving of that title as it really doesn't touch on what one might call computer science. In fact the more computer-sciencey parts are pretty poor – for example, the section on tail recursion is complete crap that will just confuse someone who doesn't already know the what and why of tail recursion.
If you're dead set on Windows and C++ you don't need VS Pro, MS have a free version. It's unlikely you'll really need the extra features that come with the pro version. Also once you're past learning the basics, read a copy of Effective C++ and Exceptional C++. And try not to get sucked too heavily into the weirdisms of the Windows style of C++ programming, they do funny things over there.
Effective C++
More Effective C++
and Effective STL
> Is there a true singular source to learn Java?
Unfortunately, no. There are 1000s of places to learn Java. The right choice is dependent on your skill level and what you want to build (e.g. web apps, mobile apps, desktop sevices, etc.).
If you need some recommendations, start with The Java Tutorials on Oracle, followed by Effective Java.
If you need a comprehensive overview of the language, you can use Java: The Complete Reference 9th Edition.
The feedback about "jargon for development" can be solved by going through some books cover to cover, making sure you understand the theory, and implementing the exercises. I understand that feedback to mean that the person who gave the feedback believes there is too high a chance you will inflict damage on the codebase by making decisions not grounded in solid theory.
Examples of titles that are classics and widely known:
Algorithms (4th Edition): https://www.amazon.com/Algorithms-4th-Robert-Sedgewick/dp/032157351X (there is an accompanying coursera course).
Code Complete: https://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670/ref=sr_1_1?s=books&amp;ie=UTF8&amp;qid=1469249272&amp;sr=1-1&amp;keywords=code+complete
Clean Code: https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882/ref=sr_1_1?s=books&amp;ie=UTF8&amp;qid=1469249283&amp;sr=1-1&amp;keywords=clean+code
Functional Programming in Scala: https://www.amazon.com/Functional-Programming-Scala-Paul-Chiusano/dp/1617290653/ref=sr_1_2?s=books&amp;ie=UTF8&amp;qid=1469249345&amp;sr=1-2&amp;keywords=scala
Learning Python: https://www.amazon.com/Learning-Python-5th-Mark-Lutz/dp/1449355730/ref=sr_1_1?s=books&amp;ie=UTF8&amp;qid=1469249357&amp;sr=1-1&amp;keywords=learning+python
Effective Java: https://www.amazon.com/Effective-Java-2nd-Joshua-Bloch/dp/0321356683/ref=sr_1_5?s=books&amp;ie=UTF8&amp;qid=1469249369&amp;sr=1-5&amp;keywords=java
Haskell Programming From First Principles: http://haskellbook.com/
I included multiple languages as well as language-agnostic ones. Functional programming is the near-to-medium term future of software engineering, and most languages converging towards that as they add functional features.
I don't think bootcamp is required. Learning how to learn is the most important thing. If you get into these books, lose track of time, and feel "aha! that's how these things that I previously thought were unrelated are actually the same thing!", and are able to keep it up for weeks, then that is a good sign that you can get to where you want to be.
I've done Android for 5-6 years. It put me through college, got me a job after. It pays well, but I'm moving to another development position because I can't envision a career in android development. Keep your career goals in mind. They may be radically different from mine, and that's fine, but know them.
As for coding: Effective Java Dat gud shit. A little dated, but it's unlikely to steer you wrong. Android lags behind the latest Java versions. Android will get
Java 8Java 9 when the sun is dead.Androiddev Protip: Don't be afraid of reading the Android source code when you're trying to understand something. I'm a veteran, and I do it probably every other day. The internet is full of lies.
EDIT: fistshake @ /u/little_z for torpedoing my genius witticism
Java
I heard that Effective Java is really good if you knew the basics (you should try to read into it a bit tough, as it isn't follow a classic tutorial format, but contains best practices and "recipes".
Then again you cold try some general programming books like:
Code Complete
Design Patterns(check the Head First edition too)
Refactoring
some books about analysis and design
Web
I've just read about a really good tutorial site of Mozilla on reddit. I will look it up in a minute
EDIT: here
Two Java specific books you should read cover to cover (and keep around as an effective reference) are Effective Java and Java Concurrency in Practice, and you should also seriously consider reading Design Patterns. The examples in it aren't written in Java but they hold for all OO languages.
They did talk about some good, solid practices for Java, that really don't go out of relevance.
If you have a solid base of Java, much of what they talked about can also be found in a more cohesive format in Josh Bloch's amazing book "Effective Java" . even though this book was last published in 2008, the content is as relevant as ever, as it discusses foundational best practices.
There are a lot of good answers in there already. Clean Code is one book that I read that I feel really changed the way I think about and write code. It's not PowerShell, but the ideas apply to any language and the code examples are easy enough to read.
DON'T COMMENT!
Comments should be placed only where it explains something that's not clear by the code itself. Commenting getters and setters buys you nothing, unless they have some side-effect the user should be aware of (but then again, they should not have such side-effect in the first place).
Clean Code (http://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882) has an entire chapter devoted to this.
Btw, please also format your code normally. What you 're doing now with those weird bracing style is atrocious!
Thanks! Yeah my opinion isn't popular around here because PHPer's love their docblocks.
The book that changed my mind about them is Clean Code by Uncle Bob Martin. The book is simply amazing, a quick read, and tells you what you already know, but in an articulate way.
Two things in there that really shake up a lot of Java/PHP programmers is his view on method length and docblocks.
Regarding method lengths, he maintains that a class method should be no longer than 4-5 lines. Any longer and it needs to be split into another method because it's probably doing more than one thing (a method should do one thing only). I find this one the hardest to comply with because it requires a great deal of discipline. But boy, when you do comply with it, your code is so much easier and cleaner to read.
Obviously, this goes for programmers working on systems where resources are virtually unlimited (99.99% of all PHP programmers). An embedded programmer probably has to watch how many methods/functions are pushed onto the stack, but programmers making web apps don't need to (as much) because resources aren't as tightly controlled.
Regarding docblocks, he says they're entirely useless, and I agree completely.
For example, this is useless:
/**
*
*/
private $user_id = 0;
Why is that docblock completely useless? Because it's told me nothing about the variable, and nothing that couldn't be gleaned by looking at it's definition:
So now you've wasted 5 lines of code (not that they're a precious resource or anything, they just clutter up the rest of your code) to describe a variable that's obvious from it's name and default value.
If you need a docblock to describe a method, that's just as bad because it means you can't deduce what the method does by it's name and arguments.
Taking the only PHP project on the front of Github, let's pick a random file and pick it apart (sorry CakePHP, don't take this personally): https://github.com/cakephp/cakephp/blob/master/cake/libs/i18n.php
Look at the method translate(). It should be pretty obvious what the translate() method does in an i18n class. Picking apart the docblock:
Next, look at the clear() method. The docblock is longer than the entire method and it tells me nothing useful.
clear() is a poor name because it doesn't describe what it clears. clearBuffer() or clearTranslations() would've been a much better choice. It says it's useful for testing, but not why, so that's a useless comment, and it doesn't @return void, it returns nothing, so that's a misleading docblock.
Which brings me to another point: updating docblocks. It takes a lot of discipline to do so. I'd much rather concentrate my discipline on writing clean and clear code, unit testing, and writing good documentation outside of my code than keeping a bunch of docblocks up to date.
Thus, in summary: docblocks cloud your code and make it harder to read while adding nothing.
Clean Code
You create a program by defining what you want your program does then writing the code that does it. You become a better programmer when you write the code in a way that is safe, concise, reusable and maintainable.
There is no distinction between program and code. A program is series of code, an series of code forms a program. You write a program simply by writing a series of code, there's nothing to learn to go from "coding" to "programming".
You can then read things like Think like a Programmer and Clean Code so the programs you can organise the code in your program better and write better programs in the future.
So, there are tons of opinions on this.
Mine is that you write what makes the code easiest to reason about, read, extend, test, and maintain.
The "performance gains" you might gain for writing terse and cryptic "one liners" and non descript variable names are not even detectable unless you are talking about 100,000 lines of JavaScript and are negligible even at that scale as you should be minifying your code anyway, which makes your code terse and cryptic automatically, meaning that you should write your code so it can be easily understood rather than obsessing over microseconds of performance gain at the cost of ease of development.
There is a Zen to this, you can write too much so that the point of what you are trying to achieve is just as lost as if you crammed everything into one line.
Basically, ask your self what can I extract, is this code doing too much, can I break it down into single responsibility functions and orchestrate them in a delegator function, do my variable name's make sense, should this be refactored, what is using this code, is is this duplicated elsewhere, does this code belong in this file or in a service/repository/on the class/centralized configuration file/ etc.
Learn how to write clean code and whether other coders like it or not (usually if they don't it's because they are not disciplined and don't want to be bothered learning the proper way of avoiding common pitfalls and mistakes or following best practices in general)
Do this and I believe you will be a welcome member to almost any dev team.
As far as your courses go, the best book I can recommend is Algorithms in a Nutshell. It is a small book which quickly introduces you to most of the core algorithms you will use throughout University. It also covers measuring efficiency through "big O notation" - a very important concept in CS.
If your University's SE program is anything like the one I am familiar with, you will also be focusing on software engineering principles. The most important SE books I ever read are:
These three books have strongly influenced me as a developer
Refactoring guru is helpful: https://refactoring.guru/
Also, Clean Code: https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882 by Martin.
As a junior dev you'll have plenty of time to learn as you go. But it would be a big plus knowing the stuff in advance.
http://www.amazon.com/Effective-Covers-4-0-Specific-Development/dp/0321658701
In java, but concepts to .net craftsmanship http://www.amazon.com/gp/aw/d/0132350882/ref=pd_aw_sim_b_10?refRID=14EWEM0PD8C0XHCMS9N9
Lots of good videos here www.pluralsight.com
13 year old? I've started programming around the same age. Wow, I'm only 27 and I suddenly felt old :)
Anyway, I don't know if you want some tips, but here are a few I wish someone told me when I was starting:
have you read the book 'clean code'?
i think there will be stuff in the book you might find useful.
(the book covers the gory details of code readability)
http://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882/ref=sr_1_1?ie=UTF8&amp;qid=1427026493&amp;sr=8-1&amp;keywords=clean+code
I don't mean to be assuming too much about you, but good programmers with experience simply don't have those kinds of opinions. Those are the types of opinions you form when you're first starting out from your Programming 101 professor who is 5 to 10 years out of date. You end up with these strong feelings about pointless shit. Abstraction is your friend.
You're talking about "good code", but you've likely never even seen good code. After all, all I have to do is show you one example of good code in Java, and you'll be proven wrong, but you seem to be committed to your fallacious, likely trolling, argument.
I suggest you pick up Uncle Bob's Clean Code. I don't know that I agree with his idea of perfect code, but the ideas behind them will help you to understand what good code is.
Once you understand what the difference is between good code and bad code (hint: it's mostly about naming things), you'll be hard-pressed to explain why you think good code can't be written in just about any mainstream language.
If the components are decoupled enough than the business logic should be in service classes/packages which can be moved to another project which could be referenced by the webapp. Than you just need to set-up your webapp with backend and frontend because the logic should not know about the implementation details.
More information on this:
http://www.amazon.co.uk/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
Think about the AAA (Arrange Act Assert) principle
https://docs.telerik.com/devtools/justmock/basic-usage/arrange-act-assert
several test scenarii in the same test is a bad practice
given that1
given that2
given that3
And what about this ?
The func names are useless
def test_calc_total2():
given that
def test_calc_total3():
given that
Did you heard about clean code ?
https://www.amazon.fr/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
You should express the intent of your test in the name:
https://dzone.com/articles/7-popular-unit-test-naming
for instance:
0 is neutral for addition
a step toward parametrised test https://docs.pytest.org/en/2.9.0/parametrize.html
Clean Code has had the most significant effect on improving my programming ability. The examples are all Java, but it's completely applicable to PHP development.
Sure! This is a great desire to have.
Clean Code probably most closely deals with you're specific question. It's very readable, and uses Java for the examples. http://www.amazon.com/gp/aw/d/0132350882
But while you're looking for recourses along these lines, you might also take a look at the super thick, bit super good Code Complete: http://www.amazon.com/gp/aw/s/ref=is_s_ss_i_1_7?k=code+complete+2
Lastly, it also sounds like it might be time to start thinking about design patterns - these are ways to implement solutions to common problems in your code using well-established design principles. The "Gang of Four" book is the classic on the topic, but this one offers a more readable introduction I feel: http://www.amazon.com/gp/aw/d/0596007124/
(Sorry for lack of link formatting, I'm on mobile.)
First time see that site, but I would recommend reading:
This is a list of books I am intending to read as soon as I read through some other books.. A list I created from reading this and some other subreddits daily, so probably this should cover all your need on Clean Coding.
If anyone know any more books well worth reading I would be really glad to hear about them!
I've heard good things about a book called Clean Coder that might answer some of your questions. I've been meaning to read it myself.
The Clean Coder: A Code of Conduct for Professional Programmers (Robert C. Martin Series) https://www.amazon.com/dp/0137081073/ref=cm_sw_r_other_awd_RTd6wbGYJT9K3
Then read The Clean Coder
I think this is often due to developers not understanding what clean code is or how to motivate it in instances where it will take significantly more time to write than throw-away code. I absolutely love Uncle Bob's Clean Code book, but even more than that, his Clean Coder book talks about the skills to be a professional developer. Skills which include being able to say "no" to poor management decisions and communicate and code professionally.
If the reader must choose between the two, I would recommend the latter. And I do, to all junior developers who ask...
Yeah, that is completely understandable. It really depends on how much time you want to spend on other things besides programming.
But be aware that in our profession, we are expected to always improve our skills on our own time. So if we put in 40 hours at work every week, we should also spend another 20 hours practicing and learning.
Check out the book "The Clean Coder: A Code of Conduct for Professional Programmers": https://www.amazon.com/Clean-Coder-Conduct-Professional-Programmers/dp/0137081073
A lot of the people that get into the top companies follow a lot of principles described in that book.
First off starting with some non financial advice stuff
It seems you have things sorted from a technical ability perspective but when it comes down to requirements and understanding what is needed that is something you might fall down on.
This happens a fair bit to be honest with you as systems can get a lot more complex and you are at the mercy of any business analysis which might be done, so as you say you can deliver "it" if you know what "it" is, that comes from experience but can be learnt in other ways.
Couple of book links:
Now financial questions, I would adjust your salary expectations, but it might not be out of the question for you to find something in that area especially depending on how commutable Manchester is, but there are places everywhere which do this kind of work, just might find competition is different.
Cara, reinventar a roda não é ruim! Resolver problemas clássicos é uma ótima maneira de aprender e praticar é a melhor maneira de melhorar em algo. Eu sou o tipo de cara que gosta de aprender as coisas na prática então sou suspeito de falar mas vai lá e desenvolve. Essa minha aposta com meus amigos é justamente para nos forçar a isso, desenvolve qualquer coisa mesmo que seja algo completamente inútil, que é melhor do que ficar parado. Umas semanas atrás, nessa aposta um dos meus amigos desenvolveu um script que calculava se era ecologicamente correto urinar no chuveiro ou na privada, utilidade real do projeto é nula, mas fazendo isso ele já começou a aprender uma nova linguagem e investiu tempo em se tornar um programador melhor. Realmente meu conselho é faça, desenvolva! Uma dica é pegue pequenas coisas do seu dia-a-dia e resolva elas com programação, por exemplo, uma vez eu fiz um script que me perguntava quais ingredientes eu queria em um lanche, ai ele varria o site do iFood e me falava qual era a opção mais barata que eu tinha. Não tinha necessidade alguma de fazer isso, era muito mais rápido fazer uma busca manual, mas na época isso me ensinou a usar a BeautifulSoup e foi super divertido de fazer.
First book I recommend to any programmer, no matter what they're working on, is The Pragmatic Programmer. Excellent stuff.
If you don't get a shot at low-level coding at work, get yourself an Arduino kit and just hack away. Apparently the language is similar to / based on the C programming language. I use C every day.
To do well with embedded systems, real-time, device driver, or kernel type stuff, you have to really, really, really, understand what the hardware is doing. I was able to learn gradually because I started programming when there was one CPU and no cache memory. Each hardware operation was straightforward. Now with multi-core CPUs, multi-level cache memory, multiple software threads, it becomes a bit more complex. But something like the Arduino will teach you the basics, and you can build on that.
Every day I have to think asynchronously - any operation can happen any time, and if they share memory or other resources, they can't step on each other. It can get hairy - but it's really fun to reason about and I have a blast.
There's a lot more I'm sure, but get started with some low-level hacking and you can build from there.
If you want to get meta, many of the best programmers I know love Godel, Escher, Bach because it widens your mental horizons. It's not about programming per se, but I found that it helps my programming at a meta level. (and it'll give you a lot to meditate on when you're baked!)
Read http://www.amazon.com/Pragmatic-Programmer-Journeyman-Master/dp/020161622X
I just picked this up the other day, and was surprised how good the advice was. It's geared towards programmers, but has a lot of interesting lessons that can be appplied to anything.
Pragmatic Programmer: From Journeyman to Master
Accelerated C++
There ya go. Now you don't have to take an entire class to learn C++.
> Other resources that move a little faster?
I learned C++ from the book Accelerated C++ and I recommend it to everyone that wants to learn C++ seriously. The learning curve is a little steep, but with some dedication you can work yourself through it in a month or three.
Accelerated C++
Pick up a copy of Accelerated C++. It starts at the very beginning and takes a more modern approach to teaching C++ than a lot of the other books on the market.
It's part of the "C++ in-depth series" that also has a bunch of other great titles like Sutter's Exceptional C++.
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 Python.org 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.
I just went through Accelerated C++ by Koenig and Moo. It helped me learn most of the basic ideas from strings and pointers to polymorphism and template classes. Very well written, though I did need to google a few things and ask people I knew sometimes. I haven't done any online courses. I think I will work on personal projects using C++ from now on to learn, and google things to fill in the gaps.
Accelerated C++ was made for that purpose. Most of the low reviews are beginners complaining that they couldn't follow, or complaining about the "paper quality" (mine is fine).
If you'd like to take another stab at C++, I recommend Accelerated C++.
Grab a copy of Accelerated C++ and give it a few hours. You should know whether C++ is for you.
I've been using Accelerated C++ (you can find pdfs of it pretty easily if you don't want to buy it). It seems to be serving me well so far.
If you want to learn, then pick up a book and start studying. Don't just post about it on a forum. There are resources available that describe good books to pick up for C# or C++, but I'll save you the trouble and recommend you Accelerated C++.
This one is very good indeed.
My only reservation here is that it's not really a TDD exercise. TDD typically involves choosing and writing tests for the functionality being added next by the developer, as opposed to here where the test dictates the next piece of functionality to add. It's a subtle difference, but a tangible one.
Now I'm not saying that this isn't a good idea. I'm not saying it isn't useful. Just that it's not quite TDD, as the design evolution is already in place for you, and you're just writing the code.
For a great example of what I'm talking about, check out Kent Beck's Test Driven Development, By Example. He walks through developing a few applications using TDD while keeping a "mini backlog" of what to do next, constantly adjusting the priorities.
Again, not putting this down, just not quite sure if it's as much as a TDD exercise as a testing exercise. But it's an interesting concept...
Test, test and test. Read about TDD (https://www.amazon.com/Test-Driven-Development-Kent-Beck/dp/0321146530). Learn about the tools (phpUnit, phpSpec, behat) and start using them. You will find hard testing at the beginning, like everything, but later you won't want to work in without tests.
Apart of that, learn how the composer package manager works and don't do anything without it. Don't reinvent the wheel and use components that someone already invested a lot of hours in (auth, orm, microframeworks).
Think about your systems as a composition of pieces that work well together, without need of coupling to a specific framework.
IMO you should go beyond learning node.
Learn javascript (node is just javascript with core libraries).
Actually don't learn javascript, learn how to code.
Even more, learn how to learn.
I'm not the only one with this opinion: http://blog.codinghorror.com/please-dont-learn-to-code/
Also a side point: learn how to test. Testing (may it be unit, behaviour, …) is really important. It helps you code better, have a stronger code (less bugs, or more easily identifiables), more maintainable, and so on.
If you know the basis of code, and how to learn, not only you'll know node, but you'll potentially know php, ruby, scala, whatever.
I strongly encourage you to read:
Those books are references to a lot of developers and will teach you techniques that you'll be able to apply not only to node, but to the most of languages you'll ever encounter.
I have a similar story, and came from a procedural background, too.
My eureka moment came when I started to understand the importance of Test-Driven Development. Test-driven Development by Example is the book that tipped the scales for me. There are more modern and pertinent examples now, but this book is a classic.
TDD will help your programming be more declarative, which will in turn help you work with frameworks like Unity.
Happy coding!
Stroustrup's book is considered (one of) the best for beginners. Lots of exercises in every chapter.
Link: https://www.amazon.com/Programming-Principles-Practice-Using-2nd/dp/0321992784
Programming: Principles and Practice using C++ 2nd Edition is made by the creator of C++ himself. This book is meant for first year computer science students to learn to program via C++. There are sections within the book that cover GUI and other UI conventions, however it focuses mostly on programming principles. It is a great book to introduce yourself to Programming and C++.
10/10 would recommend Programming Principles and Practices by Stroustrup
https://www.amazon.com/Programming-Principles-Practice-Using-2nd/dp/0321992784
I would recommend Stroustrup's book for C++. Then, like the other's suggested, hit up Hackerrank or something and then maybe try some projects of your own.
If this is your first programming language its a tad unfortunate that it has to be C++ but by no means does it mean it is bad or anything. In fact its the language most aspiring computer scientists started out with in college prior to the 2000s.
You can start off with
Programming: Principles and Practice Using C++ and then going onto The C++ Programming Language, 4th Edition after completing the first one. There is also C++ Primer that is also highly recommended as another book for starting out.
A book along with web searches when you have questions will get you pretty far. Having someone to ask questions if you get stuck on something conceptually is also useful. The best advice I can give you is to really play around with the language as you are learning and do most of the practice exercises too. Stroustrup also has solutions to the exercises from the first book I mentioned online. Hopefully you have some months available to learn the language. On top of that you might need to learn some computer science topics like data structures as well. You just can't rush these things but you can accelerate it a little.
As for me, my C++ knowledge is 'rusting away' by the day. I learned the STL with C++ when it was made official only a couple years after (like over 10 years ago). Nowadays you have Boost and the language itself has changed. I have not presently needed to update my C++ knowledge to what is latest and greatest but I shall.
Also worth pointing out is that In my experience, when you work with different companies you might find that you never use official C++ libraries and most current language features, but you are supporting legacy stuff that was first written maybe 20 years ago when not even built-in STL was available. This means either you are going to use some now-arcane implementation of someone's version of base libraries or the company rolled their own from the ground up many years ago, and because its so well entrenched in the code-base it continues to be used many years later. Not a big deal, but you might want to find that out for yourself, that if you are learning the latest and greatest of library and language features - you might or might not be using it in practice with your company.
You can PM me if you have questions but I'm not sure I can commit the amount of time you might need in a tutor role.
If you're only gonna read one book it should probably be this one: https://www.amazon.com/dp/0321992784/
That said, the idea of my producer "deep diving into the project" absolutely terrifies me. If you want to learn the basics of programming to make communication a little easier then that's great but nobody is going to want you touching code. Being able to write C++ - especially C++ learned quickly - doesn't make you a good developer.
> I want to return response in real time to javascript
I'm about to get really thorough with my response so, "hold on to your butts"
&nbsp;
As /u/Mike312 hinted at, this is not how PHP and vanilla Javascript works, and as such you would have to seek alternative frameworks or languages(like Websockets, NodeJS) or you can keep reading for an alternate solution.
&nbsp;
What you must understand is that PHP is code that lives on and is rendered on the back-end (server). That means that by the time the front-end (browser) has access to the page, the PHP code on the server has already executed.
&nbsp;
Now that you better understand relationship between PHP & Javascript means you have two options, a simple one and a more complex one:
&nbsp;
Simple Option: Abandon real-time
&nbsp;
Since you seem to be a beginner when it comes to PHP, this is the option I recommend as it is the simplest and fastest. In this case, you would have something on the front-end, like a button, that would call a new page. This page will render the results of the function I provided you.
&nbsp;
To break it down:
&nbsp;
&nbsp;
&nbsp;
&nbsp;
&nbsp;
&nbsp;
&nbsp;
Complex Option: Explore AJAX
&nbsp;
AJAX or Asynchronous JavaScript and XML allows your browser(front-end) to make calls to your server (back-end) without reloading the page. This means that, as an example, you can create a button on the front-end that executes a javascript function. The javascript function would then make an AJAX call to your server, and you could return that server data WITHOUT having to reload your page. Please see the link I provided above for a very good example.
I won't write up full on code for you that shows you how the HTML/JS/AJAX/PHP all interact but, here is an outline of how I would do it:
&nbsp;
&nbsp;
&nbsp;
&nbsp;
&nbsp;
&nbsp;
&nbsp;
I know this is a lot of info to take in, but it should help implement a simple solution, then as your knowledge grows you can implement the complex solution.
&nbsp;
As a side note, if you are really looking into learning front-end/back-end development, I recommend the following books:
Web Design with HTML, CSS, JavaScript and jQuery Set
PHP & MySQL Development
These books are a fantastic resource: Web Design with HTML, CSS, JavaScript and jQuery Set to really get to grips with the front end fundamentals.
And if she wants to dig deeper into the more advanced front end world, buy a course about react. But not before she gets the fundamentals absolutely right.
these books are great if you dont know much html and css
http://www.amazon.com/Web-Design-HTML-JavaScript-jQuery/dp/1118907442/ref=sr_1_1?s=books&amp;ie=UTF8&amp;qid=1456957990&amp;sr=1-1&amp;keywords=jon+duckett+html+and+css
and do a great job explaining the relationship between css and html in my opinion
id also super recommend if you're a beginner using bootstrap, you can read more about it here http://getbootstrap.com/ (its not integrated with dreamweaver too!) and there are plenty of youtube videos on it for creating simple but really great sites, its fully customizable and based off a grid structure which if you're a print designer you will love i think.
I'm a big fan of Web Design withHTML, CSS, JavaScript and jQuery Set
The other two that are mentioned are pretty fantastic as well.
Hey man. I'm currently doing what you are trying to do. I'm in my 4th-ish month now and having a blast. Right now I'm diving into javascript and I'm finding that that's where I'm having the most fun. Even though it's a fun time, I have to stay disciplined because sometimes I do fall off the horse. I try to make sure that I am studying 5 times a week 8 hours a day, but I don't always hit that mark. Pretty much trying to make it a full time job. I feel like I'm not quite job ready yet, maybe 2-3 months of learning and building projects. Thats the thing, just keep building websites. Here's a list of project ideas and follow FreeCodeCamp and do their challenges.
I recommend looking at FreeCodeCamp. Its free and they have a good curriculum and the best part are the Javascript challenges and mini projects they have you do and there is a pretty solid community and Gitter chat. Check out Jon Ducketts HTML & CSS and Javascript Books. Eloquent Javascript, from what I'm told, dives into JS a little deeper and I'm reading that currently. Lastly, I would also subscribe to something like Treehouse. It's $25 per month and they have a huge library of videos that are pretty good.
edit: I want to add also that there really are a ton of resources out there. So if one of the resources I suggested doesn't work for you, dont sweat it, you will be able to find another. But I do recommend learning from multiple resources instead of just leaning on one.
It can be kind of overwhelming diving into all of this stuff so please feel free to ask if you have any questions. Feel free to PM any time
I swear by Jon Duckett's books: HTML & CSS, and Javascript & Jquery. You can get the set here.
I'm 18 years old and started web design when I was 16, my dad is in his 50s and has been in the IT industry for over 25+ years. He use to do websites for people like small HTML and CSS and asked me the same question what could he learn today.
My advice is to learn frameworks like Bootstrap and Foundation, and focus on Jquery and the rest will come naturally, from what I dad use to do a lot has changed in the industry in the past 5 years so also read some good books at a local bookstore on HTML, CSS, and JS.
Here is some books I recommend this is practically my Bible:
https://www.amazon.com/Web-Design-HTML-JavaScript-jQuery/dp/1118907442/ref=sr_1_1?ie=UTF8&amp;qid=1521745810&amp;sr=8-1&amp;keywords=john+duckett
If you really want a book, there are a few that I've come across that I've liked and will suggest. Eloquent Javascript is a good one (it's free online!)
https://www.amazon.com/Eloquent-JavaScript-Modern-Introduction-Programming/dp/1593272820
Depending what you want to learn to do, also good:
https://www.amazon.com/Web-Design-HTML-JavaScript-jQuery/dp/1118907442/ref=pd_lpo_sbs_14_t_0?_encoding=UTF8&amp;psc=1&amp;refRID=YZ1P5N33ZRNPZG6SNM27
You just asked about books, but I would suggest unless you REALLY know you learn best by a book, I'd start with online tutorials (I liked Codeacademy) just to quickly get your feet wet. Codeacademy was a good way to learn the basic syntax you'll need. The books I've read, while great, tend to go deeper (not good at this stage IMO) than online tutorials which negate your "quickly" condition. Looking back, I didn't get a lot from the books until I was comfortable making code that did SOMETHING (and not much more) on my own. To me, that's the most effective way to learn quickly these days. It's easy to get sucked down a rabbit hole of feeling like you need to be an expert to start but looking back this is the plan that would have saved me a lot of spinning my wheels: 1st, do online tutorial (just 1 MAYBE 2); 2nd, then code SOMETHING (just to see you can make the computer listen to you); 3rd, When you feel like you can do something but don't understand exactly why or how it works THEN I'd get a book. That's when you'll get the most bang for your buck IMO. It's so easy to spin your wheels thinking you're one book or tutorial away from becoming an expert. It's cliche but the best thing really is to learn a little and then start making things. Take advantage of supportive programming friends or communities and don't be afraid to ask for help. You will learn more by making silly mistakes than if your code magically works the first time. Hope this helps!
I found that the Codecademy course helped me a little, but I also picked up these books by Jon Duckett. I'm the type who likes to have a book handy for reference and these have been great so far.
"Automate the Boring Stuff" and other books the same author are free online - http://inventwithpython.com/
There are other free books for beginners
See more links on /r/python (in right column)
---
EDIT:
Python Programming for the Absolute Beginner is for absolute beginners. Every chapter describes one element and you write one program or game.
Learn Python - a lot of information - 1600 pages.
Well, what language?
I actually JUST got back home about an hour ago from riding on my bike to the library (check out my reply to /u/zabzonk ) for one of if not THEE book that has helped me most when I was first interested in programming.
[Python Programming for the Absolute Beginner, 3rd Edition - by Michael Dawson] (http://www.amazon.com/Python-Programming-Absolute-Beginner-3rd/dp/1435455002/ref=sr_1_1?s=books&amp;ie=UTF8&amp;qid=1405791222&amp;sr=1-1&amp;keywords=python+programming+for+the+absolute+beginner)
The book itself has a "fun" writing style, at least enough to make me engaged in the reading, the examples are easy to understand, and it helped me grasp basic concepts very quickly. Also, Python 3 itself if a really solid pick for a first language IMO.
Really though, check out tons of books on one language, even if you don't read them all, you can sample a bit of each to see which one you want to read. And if you don't understand something, try reading it in one of the other books to see if you understand THAT example. It might also help you a little bit to pick up a book on a DIFFERENT language, in my case I REALLY started grasping concepts when reading [Beginning Programming with Java For Dummies - by Barry Burd] (http://www.amazon.com/Beginning-Programming-Java-Dummies-Burd/dp/0470371749/ref=sr_1_4?s=books&amp;ie=UTF8&amp;qid=1405791600&amp;sr=1-4&amp;keywords=Java+for+dummies) because his writing style was really entertaining and had me entirely focused and learning the whole time.
In the end, I still can't code much worth 2 cents, but I've touched on C++, Python, Java, and C# now and really understand the concepts of programming without having programmed much of anything. I'll tell you right now the reading is important, but PRACTICE. MAKES. PERFECT.
Read, and code every example in the book and try to put your own twist on it. Once you understand a little, try for a simple idea you have in mind, maybe a Dice Roller with X amount of dice and X amount of sides? Maybe tic-tac-toe? Whatever sounds like a fun little project, try to make it as you learn. And any GUI (graphical user interface) programming is best saved for last, learn how to code before you learn how to make pretty menus.
This set me up for my first term in uni where we learnt python: http://www.amazon.co.uk/Python-Programming-Absolute-Beginner-Dawson/dp/1435455002.
It begins right at the begining and makes learning fun as you work your way through the book making games and by the end you would have made a game with a fully functioning GUI.
"Dive into Python 3" (http://www.amazon.com/Dive-Into-Python-Mark-Pilgrim/dp/1430224150/ref=sr_1_2?s=books&amp;ie=UTF8&amp;qid=1411398040&amp;sr=1-2&amp;keywords=dive+into+python) and Learning Python (I have the fourth edition, but this is the last one: http://www.amazon.com/Learning-Python-5th-Mark-Lutz/dp/1449355730/ref=sr_1_1_ha?s=books&amp;ie=UTF8&amp;qid=1411398055&amp;sr=1-1&amp;keywords=learning+python)
> I'm just afraid to fail that too or be too overwhelmed.
You said you learned math on your own via Khan Academy and you're afraid to fail. Clearly you need a refresher about what Khan Academy is all about. :)
I think you need to become more structured in your studies and really sit down to complete something from start to finish rather than knowing a little bit about a lot of things. I'd suggest picking up a book like Learning Python and setting a schedule each week where you'll sit down and read the book. Once you complete that book cover to cover, you can move onto a book like Programming Python.
&#x200B;
I absolutely think college is a great option for you. If you're scared, start off by getting 2 year degree then move onto a 4 year degree. What a disservice to the world it would be for such a curious mind to be wasted working in a construction store.
&#x200B;
Always remember bud, life is a marathon not a sprint.
&#x200B;
You don't have to know anything about programming going in, as aixelsdi mentions. If you want to get ahead, here's some information which may help you do so. The rest is up to your own initiative. It can never hurt to know more about CS or more languages, as long as you don't waste time complaining about what's better in [insert language of choice].
I wouldn't recommend learning data structures and algorithm analysis before coming to UCI. Not because they aren't fundamental, they are. But because most people find it harder to learn those abstractions before learning the tools that utilize them (Python, C++, etc), which is why ICS 46 and CS 161 aren't the first classes taught. If you like math proofs more than math problems then maybe go that route, it could be helpful as iLoveCalculus314 mentions.
Languages: The CS introductory series (31-32-33) which you'll be taking first year is taught in Python. It switched to this because it's a good first language as a teaching tool. Right after you're done with Python, 45C will teach you C++ and 46 will use C++. The lower division systems core (51-53) generally use C or C++ but it differs by professor. Knowledge of Python will be useful in making your first year easier. Knowledge of the other two will make your next three years easier because they're common mediums for upper division courses. But you should be able to pick up a new language for a specific problem domain by the time you reach upper division.
Courses: If you want to get a head start on planning your courses, check the UCI Catalogue - Computer Science page. At the bottom it lists a sample of what your schedule over the 4 years might look like. That page is for the "Computer Science" major, for other majors in ICS see here.
Course Resources: You can actually view the Schedule of Classes without being a UCI student. Select a term (like Fall 2014) and a department (like I&C SCI) and it will list what classes were offered that term. Most lower div will be I&C SCI, most upper div will be COMPSCI. From the results you can go to the websites for those courses to see a syllabus, books used, etc. For example, here are the current websites for the introductory series ( ICS 31, ICS 32, ICS 33 ).
Your course professors and books and assignments will NOT be identical to those, but looking at what's currently taught will give you a pretty good idea of what the course entails so you can pre-learn anything that sounds difficult.
Books: If you have to pick one book to learn before coming to UCI, I would highly recommend C++ Primer, 5th Edition. It's very well structured as a self-teaching tool AND as a reference manual. You won't come away with any Python knowledge, but picking up Python as someone versed in C++ is easier than the other way around, and you'll find 45C much easier as well since you can focus on language quirks rather than fundamentals.
If you choose to learn Python first, Introduction to Computing Using Python: An Application Development Focus is the book currently suggested for ICS 31/32, and Learning Python (5th Edition) is suggested for ICS 33.
Another solid circlejerk book in the CS community is Code Complete, but I wouldn't recommend reading that until later on since it's more of a "best practices" book.
Here's the thing: learning any language takes practice: fingers on the keyboard, brain engaged in solving problems. Any other resource that you use, whether books, classes, or whatever, will only be a guide to show you what and how to practice.
So ask yourself: when you tried learning with a book, did you do it sitting in front of a keyboard with an IDE up, and actually do the hands-on sections or the examples in the book? If you did and still had trouble, then sure, an MIT Open Courseware class might help you: maybe you just learn in a different way.
I myself learned Python partly by going through the MIT Intro to Programming OCW, and found it be a great resource. By contrast, I learned C++ by working through this book. In both cases, though, I had to actually do the homework, work my way through the practice problems, and get the hands-on time, in order to become comfortable with the language.
So, TL;DR: it depends entirely on whether you're willing to commit to putting in the work to practice.
I hope you meant this book. C++ Primer is a far better text than C++ Primer plus. The only thing I didn't like about C++ Primer is there were no solutions for the exercises. So when I was going through it, I couldn't compare my answers.
Also here's a stackoverflow post that helped me out in regards to C++ books.
http://www.amazon.com/Primer-5th-Edition-Stanley-Lippman/dp/0321714113
Are you referring to C++ Primer 5th Edition or C++ Primer Plus 6th Edition ?
I had actually read that C++ Primer Plus wasn't as good as C++ Primer so I went ahead and bought C++ Primer 5th edition to learn C++ more in depth. The book has updates for C++11 so I was curious if you have a source for Sutter's claim that it's prehistoric.
My problem now is that the book is so big (~1000 pages), that I'm debating whether I should read through the whole thing page by page or just use it as a reference. I feel like if I skip one little detail of some feature, it could bite me in the ass later.
\ Found that info through stackoverflow's list of recommended C++ resources - search for "C++ Primer" and see the related footnote about C++ Primer Plus
If you want to learn C++, this book treated me well. C++ Primer
It only goes to C++11, but honestly the differences between 11 and 17 are small compared to the differences between 03 and 11.
https://www.reddit.com/r/cpp/comments/5pqv8o/whats_the_best_c_beginners_book/
People in that thread seem to recommend this book
Honestly, if I may, suggest that you use C++ Primer as a reference book (not C++ Primer Plus, two different books).
Also, your voice is REALLY quiet in the video. It really needs to be boosted, a lot. If I turn my speakers up to where I can hear you normally, and then start anything else, I'll be blown away.
And I hope that your video is just a "demo" video, because if you start teaching a beginner C++ using structs and functions and console output, you are going to confuse them. You need to start from the beginning.
I would also teach them the basics of the command line and how to invoke the compiler and linker manually, and show them batch files and a super basic makefile. These are things that are very helpful to know and they are always skipped over in tutorials. Here is a makefile that I made that is really simple to use, fairly simple to understand, and has a decent set of features. Feel free to use it or distribute it. https://pastebin.com/qDTM1WNC
http://www.learncpp.com/
https://www.sololearn.com/Course/CPlusPlus/
https://www.amazon.com/Primer-5th-Stanley-B-Lippman/dp/0321714113
https://www.amazon.com/Effective-Modern-Specific-Ways-Improve/dp/1491903996 (this one is a little more advanced, should be read when you are comfortable with c++)
https://www.amazon.com/C-Programming-Language-4th/dp/0321563840
Currently slated for end of the summer, but I'm sure Lippman's 5th edition of "C++ Primer" (not to be confused with Prata's "C++ Primer Plus") will be very good.
Looks like it's scheduled for end of the summer. I was hoping Lippman et. al. would put out a new version for C++11, but I wasn't sure until I saw it mentioned recently here on reddit.
C++ Primer 5th Ed. is the recommended C++ book for beginners and is excellent. The Zyante thing they're doing is this interactive online book which is just kind of ok, although I didn't do it for CS10. Definitely talk to the TA and professor if you need help (it sounds like this is only online interaction? kind of sucks), the school also has SI (student instructor) sessions that you can attend for this course along with a tutoring office that has instructors for all types of courses. Keep in mind that the quarter system goes by quickly, and you don't want to fall behind.
I think if you start working through C++ Primer you'll be more than prepared for the course. Oh and welcome to UCR!
Yes, this is good books
&#x200B;
I can recommend https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844 this books instead Sedgwick
Or if you go further https://www.amazon.com/Computer-Programming-Volumes-1-4A-Boxed/dp/0321751043/ref=sr_1_1?crid=3KIIUSO0OCYLD&keywords=donald+knuth&qid=1566900852&s=books&sprefix=donald+kn%2Cstripbooks-intl-ship%2C369&sr=1-1
Also see this https://www.amazon.com/Structured-Computer-Organization-Andrew-Tanenbaum/dp/0132916525/ref=sr_1_5?crid=2PZADWCTIJ5EM&keywords=tanenbaum&qid=1566900893&s=books&sprefix=tanen%2Cstripbooks-intl-ship%2C263&sr=1-5
CS is almost pure math, especially beyond the freshman year. You can learn to code with almost no advanced math. So, what's up with that?
Numerous---everyday---apps are actually very simple coding, which do not require much math. This lures people who code into thinking math is not required in programming. That is a false assumption. This is the rub...anything advanced in technology requires equally advanced mathematics. AI, machine learning, data science, robotics, graph theory, geometric modeling, parallel architectures, electronics, telecom transmissions, cryptography, etc., etc., etc., all require advanced mathematics skills. The list goes on forever.
You'll never be a great programmer without at least a strong foundation in discrete mathematics (maybe you'll be a elementary app coder or maybe you'll be a low-level developer). Anyone saying you don't need math in CS is wrong. Anyone saying CS is easy is mistaken. For those that claim all you need is 3rd or 4th grade math, are 3rd or 4th grade coders. At least 1/3 of people drop out of computer science degrees---stating it was just too difficult.
I suggest to everyone to pick up The Art of Programming, by Knuth (and/or Introduction to Algorithms, from MIT Press). Come back and tell us if you think CS is hard, and...if math is required in programming. Find a quiet corner to cry in....the books are as intense, as they are inspirational.
My advice? Take a few discrete mathematics courses. You may have a job one day that requires you to know the cost of nodes in a tree, based upon the mathematics of recursion and exact powers: Example - That isn't 3rd grade math. Stare at this gem for a while: https://www.tug.org/texshowcase/cheat.pdf
The good news is...you live in the best possible era to learn CS. Millions of resources are at your disposal. You just need to be dedicated.
-MrNetTek
The Art of Computer Programming - this is a 4-volume series (4A is out; 4B, 4C, 4D coming soon; 5 planned for 2025). It'll take a lifetime to master everything written in this series :)
Questo è un classico anche se un po' datato: https://www.amazon.it/Effective-Java-Joshua-Bloch/dp/0321356683
Ti consiglio di abbinarlo a https://www.amazon.it/Java-Action-Lambdas-functional-style-programming/dp/1617291994 per le ultime novità di java 8 (che sono fondamentali).
Sono in inglese e te ne devi fare una ragione... il 99% del materiale di qualità è in inglese.
P.S. Nè html nè css sono "linguaggi"
Resources to help: Effective Java 2nd Edition by Joshua Bloch http://www.amazon.com/Effective-Java-2nd-Joshua-Bloch/dp/0321356683/ref=la_B001CDCVUG_1_1?s=books&amp;ie=UTF8&amp;qid=1449594086&amp;sr=1-1
Basically this entire book has most of the intricacies of Java boiled down. If you can commit this book to memory than most Java interviews will be killed.
Java 8 is definitely a new take on the language but most shops haven't gotten to it yet so knowing Java 7 is pretty much all you need.
It depends, honestly. There is some discussion about this in Effective Java if you haven't read it.
I'll summarize some of what Josh Bloch says on the topic here:
> If a class is accessible outside its package, provide accessor methods...If a class is package-private or is a private nested class, there is nothing inherently wrong with exposing its data fields
For example --
public enum Planets
{
MERCURY(1), VENUS(2), EARTH(3), MARS(4), JUPITER(5), SATURN(6), NEPTUNE(7), URANUS(8)
private double _rateOfSpin;
public Planets( double rateOfSpin ) { _rateOfSpin = rateOfSpin; }
public rateOfSpin() { return _rateOfSpin; }
}
If you use rateOfSpin(), you have the option of making this a derived value without introducing a breaking change. For the cost of an additional "() -- you get some flexibility. If your enum is private or package-private, you can eschew the accessor with minimal risk.
Hope this was helpful.
If you're already past all the "learning java" type books, read this:
Effective Java: http://www.amazon.com/Effective-Java-Edition-Joshua-Bloch/dp/0321356683
From Data Classes and Sealed Types for Java:
>Digression -- enums
>
>If the problem is that we're modeling something simple with something overly general, simplification is going to come from constraint; by letting go of some degrees of freedom, we hope to be freed of the obligation to specify everything explicitly.
>
>The enum facility, added in Java 5, is an excellent example of such a tradeoff. The type-safe enum pattern was well understood, and easy to express (albeit verbosely), prior to Java 5 (see Effective Java, 1st Edition, item 21.) The initial motivation to add enums to the language might have been irritation at the boilerplate required for this idiom, but the real benefit is semantic.
>
>The key simplification of enums was to constrain the lifecycle of their instances -- enum constants are singletons, and instantiation is managed by the runtime. By baking singleton-awareness into the language model, the compiler can safely and correctly generate the boilerplate needed for the type-safe enum pattern. And because enums started with a semantic goal, rather than a syntactic one, it was possible for enums to interact positively with other features, such as the ability to switch on enums, or to get comparison and safe serialization for free.
>
>Perhaps surprisingly, enums delivered their syntactic and semantic benefits without requiring us to give up most other degrees of freedom that classes enjoy; Java's enums are not mere enumerations of integers, as they are in many other languages, but instead are full-fledged classes (with some restrictions.)
>
>If we are looking to replicate the success of this approach with data classes, our first question should be: what constraints will give us the semantic and syntactic benefits we want, and, are we willing to accept these constraints?
Yes I agree. I'll have to take a look at that animation again. Its quite difficult as I'm using a list view. Book wise, for Java, I cannot recommend this highly enough,Effective Java: Second Edition, http://www.amazon.co.uk/gp/product/0321356683?psc=1&amp;redirect=true&amp;ref_=oh_aui_detailpage_o00_s00. For Android its an ever evolving environment so books tend to go out of date very fast. I'd recommend doing a udemy or udacity course
> I am a relatively new to development
If you're new to development, it's hard enough just to learn Rails by itself. In addition to the Rails concepts (e.g. ActiveRecord, view rendering, etc.) there's Ruby, databases/SQL, servers, HTML, CSS and JavaScript. Even if you're already comfortable with all those things, it's pretty hard to throw testing into the mix. When I first got started my question was, "What do I even test?" Do I write unit tests? Integration tests? View tests? Controller tests?
My advice would be to forget about Rails for a little bit and just practice testing Ruby by itself for a while. Then, once you're comfortable with testing Ruby, it will be easier for you to go back and try to write some tests in Rails.
> What is your recommendation on if I should focus on rspec vs minitest?
A person could make technical arguments for either. Deciding which testing framework to use depends on your objectives. If you're teaching yourself testing to become a more marketable developer, then I would definitely recommend RSpec. Almost every Rails project I've worked on (20+ production projects) has used RSpec. Having said that, it's less important which tool you choose and more important that you have a solid understanding of testing principles. I personally chose RSpec and I'm glad I did.
Here are some testing resources I often come across:
Growing Object-Oriented Software, Guided by Tests (awesome book, highly recommended)
Rails 4 Test Prescriptions (just started it, seems good so far)
Working Effectively with Legacy Code (super good book and more relevant to testing than it might seem like)
Everyday Rails Testing with RSpec (haven't bought it yet but seen it recommended a lot)
Destroy All Software (just bought it today, seems good so far)
Lastly, I myself created what I call a Ruby Testing Micro-Course designed to make it easy for people like you to get started with testing. Feel free to check that out and let me know what you think.
Growing Object Oriented Software, Guided by Tests is hands down the best TDD book out there in my opinion.
> The idea is that both DAOs join the transaction, and that either the
> data from both DAOs ends up in the DB, or none at all. The DB has some
> contraints set for the data that we are persisting.
and
> What we however really wanted to test was whether the data
> actually ended up in our DB and whether both DAOs joined the
> transaction to see if the effects of DAO1 are correctly undone
> (rollbacked) when DAO2 throws.
This is not what mocks are for. This is why you do integration testing and functional testing.
Mocks state the expections a class under test has for its collaborators, and verify behavior given those expectations. You use this to grow the interface for collaboration based on class under test's needs. Furthermore, the owner of the interface is the class under test, not the collaborator. If you change the interaction with the interface, you must verify the collaborator still meets the expecations of the class under test. This is in line with the principle of Depedency Inversion.
Thus, returning to your example, the proper question is what does the ServerFacade need from the DAOs? You grow the DAO to meet the needs of the ServerFacade. Then, integration tests should be written to verify that the DAO meets the expectations set by ServerFacade. And any time you change ServerFacade's expectations, you'd better make sure the DAO still meets those expectations by updating the integration test.
Seriously, read the book Growing Object Oriented Software Guided By Tests, written by the authors of the EasyMock framework. Before reading your own interpretation of what you think mocks are for, read how the authors of EasyMock intended it to be used.
There is a book for that!
https://www.amazon.co.uk/Working-Effectively-Legacy-Michael-Feathers/dp/0131177052
Where legacy code is defined as code not protected by tests. Really great book.
https://www.amazon.de/Working-Effectively-Legacy-Robert-Martin/dp/0131177052?ie=UTF8&tag=googdemozdesk-21&hvadid=323934261977&hvpos=1t1&hvnetw=g&hvrand=10757532144450521743&hvpone=&hvptwo=&hvqmt=b&hvdev=c&hvdvcmdl=&hvlocint=&hvlocphy=9072483&hvtargid=dsa-19959388920&ref=pd_sl_35q8ibnq4w_e&language=en_GB
If you ever work with an older codebase, check out "Working Effectively with Legacy Code".
https://www.amazon.com/Working-Effectively-Legacy-Michael-Feathers/dp/0131177052
Getting older code under test is some of the most challenging (and rewarding) work you can do.
If you're looking for a good book on this subject, I'd recommend checking out Working Effectively with Legacy Code. It's 90% about unit testing, but offers a lot of great advice.
This book is the (or a) bible for this.
Generally: you start at tests.
Yes, it's true that writing unit test for legacy project is hard. But what I have done is when implementing new feature I start using Sprout Method or Sprout Classes which are unite tested. This allow me to know that the new features I added is unit tested and works as expected. It will not be easy at first as you have to find seams or create seams for testing. But once you start doing it each time you touch the project it's get little better. Once you have something decent show it to your team and they will love it.
I found that code get uglier as there are many small classes but it's easy to maintain.
If you haven't read, I would suggest you to check out Michael Feathers' Working with Legacy Code.
"Call out" also means to make reference to, especially in the context of a book where you might "call out" a figure, phrase, or common theme. This is how it was used above.
This is the book. Next time when you don't know, just ask.
Working as a software engineer, you will inevitably inherit some code that is less than stellar and not designed for unit testing. This book is very effective and teaching techniques to overcome pitfalls with legacy code.
https://www.amazon.com/Working-Effectively-Legacy-Michael-Feathers/dp/0131177052
Working Effectively with Legacy Code by Michael Feathers
Iirc https://www.amazon.com/Working-Effectively-Legacy-Michael-Feathers/dp/0131177052 was a pretty good book and gave lots of hints on how to refactor legacy code to make it easier to replace. Been a while since I've read it though.
Sadly there are a lot of companies that operate like this and I wish I could say this isn't common , but it is, especially around non technical companies that do in-house development. However, there are lots of companies changing and trying to improve their process and code base.
Working with legacy code is something every developer has to do at some point. There are techniques to make the process easier. Checkout the book Working Effectively with Legacy Code
Also, try and follow the boyscout rule of programming. Always leave the code base slightly better than you found it. You don't have to go crazy, but little improvements here and there. Test the new code you write and over time you'll have a much cleaner and better system.
I used to work on a web application that was so horribly coupled together that any small change literally break the whole thing and cause hours of debugging. I know your pain.
My favorite was Expert C Programming: Deep C Secrets, aka the fish book.
It's very well written, and has an almost conversational tone (and some jokes) despite its technical nature.
Object oriented programming is a deep topic.
If you are looking for a simple introduction, I found Chapter 8 of this book, which is also used for the MIT
Intro to Programming using Pythonpretty good.https://mitpress.mit.edu/books/introduction-computation-and-programming-using-python-0
If you want to dive deeper, these 2 books have good descripts of OOP and other fundamentals of Programming. However, these are not specific to Python, but are probably the most recommended books in programming:
It sounds like you could really benefit from reading Clean Code. It isn't really about a specific design pattern, but an overall design philosophy. It gets mentioned in the programming subreddits all the time, and for good reason. I haven't finished it yet, but it's already had a big positive impact on the way I think about, and design my code.
Everything helps with new grads. Internships definitely help, and remember to have listed which technologies and services you used during that time.
If you want to really set yourself apart, take a look at Clean Code. Being able to skip the 'the code works but is entirely unmaintainable' aspect of a new college grad training is a huge plus.
I was looking for something inclined towards Problem Solving.
Something that helps in the approach a person should take when they are tackling a problem. What could be the possible strategies etc.
I found this one to be quite interesting: https://www.amazon.com/Think-Like-Programmer-Introduction-Creative/dp/1593274246
I know java, but currently speed learning c++ here, so that I can complete this Think Like a Programmer. Might seem extreme to try to learn a complete language just to improve my problem solving abilities, but the more I practice programming, the more I run into the very common problem of not being able to break problems down enough to solve them/ think algorithmically. This book is highly recommended for this issue, so I figured I would give it a shot, would love to learn and work together in a group.
Sicuro di volere escludere a priori i corsi/video online? Escluderesti delle ottime risorse imo. Poi dipende anche dal tuo rapporto con la lingua inglese. Se è buono, vai su /r/learnprogramming. Troverai molte risorse utili!
Ti posso inoltre consigliare un buon libro su Python suggerito da molti: https://www.amazon.it/dp/1593275994/
Someone here is a pybro but I can't remember who. Anyway, you reminded me of Automate the Boring Stuff with Python.
That's a good one imo.
Python is pretty powerful and has a shallow learning curve for being able to automate a lot of simple things and do some helpful data analysis and visualization. I recommend the book automate the boring stuff with python. Teaches you things like working with Excel, scraping data from different sources, working with regular expressions to pull data from text, etc.
I also feel like there is always demand for spreadsheet wizs. If you want to learn VBA in excel you can record macros while you manually work, view the code and learn from there.
If you know R, then Python should be no problem. Learning Python helped me learn Java, and now R just seems like another step. I think my Python resources are out of date now, since I was learning Python 2. Learn Python the Hard Way used to be free, now he's charging for it. Coding Bat is cool for practicing. Here's some MIT readings I used too, but again, theyre for Python 2 so theyre going to be out of date. I actually just picked up Automate the Boring Stuff but havent used enough of it to recommend it yet, but it definitely looks interesting.
edit: Here this post of mine from a while back has a lot more Python resources that may or may not be useful anymore:
https://www.reddit.com/r/CFA/comments/6h5566/python_resources/
Jose Portilla on Udemy has some good python based courses (and also frequents this subreddit). There's regularly sales or some sort of coupon code available to get any of the courses for $10-$15, so it's very reasonable.
For books:
https://www.amazon.com/Python-Data-Analysis-Wrangling-IPython/dp/1491957662/ref=asap_bc?ie=UTF8 ... it's not out yet, but due any day. You can also get preview access on sites like Safari Online (which would also have all the books below).
https://www.amazon.com/Data-Science-Scratch-Principles-Python/dp/149190142X/ref=sr_1_1
For general python:
https://www.amazon.com/Python-Crash-Course-Hands-Project-Based/dp/1593276036/ref=sr_1_1
https://www.amazon.com/Automate-Boring-Stuff-Python-Programming/dp/1593275994/ref=sr_1_1
No Starch Press, OReilly, APress and Manning generally have pretty good quality publications. I'd usually skip anything from Packt, unless it's specifically received good reviews.
This is the best advice here. A coding bootcamp may give you a credential that's worth the price, but the real capability is from your own work/studying/interest. And that stuff can be done for almost free. I really liked Automate the Boring Stuff -- a Python book that provides some powerful tools very quickly.
The bootcamp will be 100x more valuable if you attend already able to code.
https://www.amazon.com/Automate-Boring-Stuff-Python-Programming/dp/1593275994/ref=sr_1_1?ie=UTF8&amp;qid=1525365963&amp;sr=8-1&amp;keywords=automate+the+boring&amp;dpID=517XL4pO6jL&amp;preST=_SX258_BO1,204,203,200_QL70_&amp;dpSrc=srch
This is where i started. Automate the Boring Stuff With Python
Amazon doesn't like web scraping without permission. I would just use camelcamelcamel to get the same information minus the hassle:
from bs4 import BeautifulSoup
import requests
headers = {'User-Agent': 'Mozilla/5.0'}
r = requests.get('https://camelcamelcamel.com/Automate-Boring-Stuff-Python-Programming/product/1593275994',headers=headers)
print(res.statuscode)
> 200
price = r.text
soup = BeautifulSoup(price,'html.parser')
soup.find('span', class='green').string
> '$24.45'
He hits on a lot of the same points in his book: http://www.amazon.com/Refactoring-Improving-Design-Existing-Code/dp/0201485672/
Worth a read, certainly had an impact on how I approach refactoring and design in general.
Lol I've never heard a script kiddie ask for factoring advice... guess there is a first time for everything. Maybe try reading this -- https://www.amazon.com/Refactoring-Improving-Design-Existing-Code/dp/0201485672/ref=sr_1_1?ie=UTF8&amp;qid=1468244890&amp;sr=8-1&amp;keywords=refactoring.
Refactoring
read it. seriously. it's a great book. and it's invaluable.
Agreed. There are plenty of resources out there that will help you understand design patterns. If you're new to the concept, I would recommend Head First: Design Patterns, it might be based on Java, but the examples are simple to understand and can mostly apply to PHP as well. When you feel like you've grasped the basic concepts of design patterns, you can move on to more advanced texts, like Martin Fowler's Patterns of Enterprise Design - this is a great reference for a lot of the more common patterns. There is also Refactoring: Improving the Design of Existing Code. These are great investments that will help you with any project you work on, and will help you if you decide to use a framework like Zend which uses design patterns very heavily.
Personally, I look for code smells. You can find them formalized in Refactoring: Improving the Design of Existing Code.
The following books would be good suggestions irrespective of the language you're developing in:
Patterns of Enterprise Application Architecture was certainly an eye-opener on first read-through, and remains a much-thumbed reference.
Domain-Driven Design is of a similar vein & quality.
Refactoring - another fantastic Martin Fowler book.
15 is really young. If you're relatively presentable, you might want to try Hyvee.
That said, it looks like from your profile that you have an interest in math and coding.
If this is something you're naturally skilled at, you shouldn't be working in fast food. You should be ignoring temporary financial gains to put yourself in the best place possible for college and technical internships.
The primary way to do that is to double down on your academics. At 15, you'll probably be going into your sophomore year? Don't accept any grade but an A from here on out. There's just no reason for it. You're obviously not retarded and school is easy.
Grab an ACT/SAT prep book. Take every practice test you can find until you get your scores into the absolute highest percentile you're able to.
If available, join a cyber academy, coding, math or robotics club at your school.
Go to things like this:
http://siliconprairienews.com/2014/08/meca-challenge-2014-preview/
Read books like these:
http://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670
http://www.amazon.com/The-Pragmatic-Programmer-Journeyman-Master/dp/020161622X
http://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
You'll lose a few thousand dollars over the next few years from working a shit job but you'll also be able to get a technical internship as soon as you turn 18 making double/triple minimum wage, while you gain proficiency in a relevant field.
You'll also go from $Texas in student loan debt to a free ride, saving you 30,000 to 100,000+ depending on what school you can get into on scholarship.
You may be 15 but I have to disagree with anyone else that you're only worth minimum wage. Everyone has skills they can work on and if you really want to help your family in the long term, work on what will make you successful.
If you have any questions regarding any of this, PM me.
Not all on topic as "CS" books, more general programming, but here's a short list. I also suggest the opening chapter or two of a lot of books for stuff you don't know but are interersted in. They're generally just nice easy to read introductions.
I don't know how much reading you've done, but I've also found The Pragmatic Programmer to be a very good read. It talks about the design of a project abstractly, and has held up well over the years (1999 was the publish year!)
http://www.amazon.com/Seven-Languages-Weeks-Programming-Programmers/dp/193435659X?ie=UTF8&amp;keywords=pragmatic%20programmer&amp;qid=1464727456&amp;ref_=sr_1_7&amp;s=books&amp;sr=1-7
http://www.amazon.com/Exercises-Programmers-Challenges-Develop-Coding/dp/1680501224?ie=UTF8&amp;keywords=pragmatic%20programmer&amp;qid=1464727456&amp;ref_=sr_1_5&amp;s=books&amp;sr=1-5
http://www.amazon.com/Pragmatic-Thinking-Learning-Refactor-Programmers/dp/1934356050?ie=UTF8&amp;keywords=pragmatic%20programmer&amp;qid=1464727456&amp;ref_=sr_1_4&amp;s=books&amp;sr=1-4
http://www.amazon.com/Pragmatic-Programmer-Journeyman-Master/dp/020161622X?ie=UTF8&amp;keywords=pragmatic%20programmer&amp;qid=1464727456&amp;ref_=sr_1_1&amp;s=books&amp;sr=1-1
http://www.amazon.com/Programming-Logic-Design-Comprehensive-Farrell/dp/1285776712
As far as I'm concerned there's no better source for the information that you need than The Pragmatic Programmer.
The Pragmatic Programmer
The Pragmatic Programmer
There are two books I always recommend to anyone who is starting their Software Engineering career.
The Pragmatic Programmer: From Journeyman to Master
Clean Code: A Handbook of Agile Software Craftsmanship
Both of these books were recommended heavily to me when I joined the industry and I wish I would have read them sooner. They manage to boil down years of insight and experience into a couple of interesting and thought provoking reads. I always buy copies for my interns or college graduate level junior developers.
In my experience, good .NET code requires much more structure than front end code. These books can help you get into the right mindset of a .NET developer.
tl;dr version:
Quick background to validate the above/below: I was a 30y/o banquet manager when I decided to change careers. I had no prior experience [unless you want to count a single programming class I took in high school] but did get a job in tech support at a medium size startup while I was in school and wrote a couple apps for our department. Just before I graduated I started working at a primarily Google & Mozilla funded non-profit as their sole software engineer. I moved on after a little over two years and am now a software engineer at VMware.
Two books I'd suggest reading are The Pragmatic Programmer and Code: The Hidden Language of Computer Hardware and Software. Pragmatic Programmer is one of those classics that every good dev has read (and follows!). Code is great at giving you some insight into what's actually happening at a lower level - though it gets a bit repetitive/boring about halfway through so don't feel bad about putting it down once you reach that point.
The best thing you can do to help you land a job is have some open-source side-projects (ideally on GitHub). Doesn't have to be anything major or unique - but it will help a lot for potential employers to see what your code looks like.
The Pragmatic Programmer. Now I've never actually read this book but I plan on it eventually. You could read some of the reviews and look up other reviews somewhere else to see if it meets what you're looking for. Btw, are you studying the version of CS50 on their website?. I've been watching this as well but I've been programming for a few years now. If this is your first time and you're not completely understanding what's going on in that class it's ok. That class seems to move quite fast and sort of jumps around without detailed explanation. Make sure you're doing the projects along with the class, watching videos alone won't get you anywhere. Trust me on that one.
I'm still pretty inexperienced, so I would LOVE feedback as well!
Code should be self-documenting. Variables, functions, classes, etc. should be named descriptively. Here's a rather contrived example:
if(flag1 && flag2 && flag3)
doSomething();
What do the flags, well, actually flag? What are they meant to symbolize? What the hell does doSomething() do? At first glance, I can't tell what the point of this code is.
boolean isHireable = person.isCompetent() && person.isFriendly() && person.hasGoodHygiene();
if(isHireable)
addToCandidates(person);
If I leave this project for a year and then come back, I might forget how the underlying implementation works, but at least here, it's MUCH easier to make an educated guess.
Comments should be used sparingly. Unless there's a good reason, you shouldn't use comments to describe your code (remember, your code should be self-descriptive). What happens if the code changes, but the comment doesn't? Then the comment becomes misleading or even incorrect, which can confuse maintainers down the line.
If anything, the comment should reflect the intention of the code, rather than the code itself. That way, even if the specific implementation of that intention changes, the comment still accurately describes the purpose of the code.
You should also remove commented-out code (use version control instead!). At least in my experience, it can cause a lot of confusion and clutter.
Sometimes you'll find yourself repeating the same or similar code across many different functions. Maybe that code can be extracted into it's own function, and you just call it when you need to.
Try to keep your functions small, they should really only do one thing, and one thing well.
You might also be able to find guides for your specific technologies. For example, best practices for a designing a Java class hierarchy might not apply to handling events in Javascript. Your company might enforce a styling guide or the community surrounding a particular technology might have de facto conventions.
I've also found this book to be a pretty good resource. It's based in Java, but you can apply the principles to a lot of different areas. http://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
This is exactly what I was thinking when reading this. As someone who has been coding and doing code reviews for 20+ years, comments almost always lie eventually. They are an extra point of maintenance and most people don't maintain them when changing code.
As for long functions, your functions should really be doing one thing. A long function is a smell that tells me it is probably doing too much. The more you get into the habit of keeping things small, the more you realize how much easier it is to reason about the code you're writing and reading.
This book by Uncle Bob Martin is pretty great. Am I telling you to change your style? No. But like the person above me, I am imploring you to read more on the subject and come to your own determination.
You may want to read Clean Code !
If you haven't heard of it already,I'd recommend The Programmers Bible. The one and only book you'll ever need for writing consistently clean code.
The book Clean Code will help with improving your code in general.
Head First Design Patterns is great! But in Java. The patterns still apply to Python though.
Here are patterns in Python https://github.com/faif/python-patterns
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!
By making things and putting them on GitHub, and then you can link to your GitHub portfolio on LinkedIn. Any company worth working for will care more about the quality of your work than your certifications.
If you're asking how to learn programming in the first place, it has never been more accessible! There are countless books and guides out there for any topic imaginable. So what I told apprentices at the last company I worked was, start by reading Clean Code by Bob Martin, to get a feel for the mindset with which to approach programming.
And from there, just start making stuff-- 'Breakable Toys' we call them. After
print("Hello World")the first thing I made was an unbeatable tic-tac-toe game, and then a bunch of other random stupid stuff before I learned to do anything interesting or marketable.OPINIONATED STATEMENT ALERT: You must make your first project in Elm! :) it's by far the most beginner-friendly language I've ever worked with, and really just an overall delight (even for non-beginners). Even though it's not the most marketable language right now, it's the best intro you could have into programming, and will give you a great foundation to learn other languages!
Edit: Also worth looking into apprenticeship opportunities. The only well-known one I can recommend in good faith is 8th Light's which I believe is free until they start paying you-- so a better deal than college I would say! Thankfully, many smaller local businesses are starting to embrace the apprenticeship model as well, so keep those opportunities on your radar.
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(" ") &amp;&amp; !p.equals(""))could easily be a methodisValidWord(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 tofor (String p: parts) {
stack.push(p);
}
Also, while we're here, why
pand notpart? If you're trying to go full on readability, one letter variables are basically outlawed except as indexes.for (String part: parts) {
stack.push(part);
}
While we're still here, why
partsand notwords? 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(" "));
Collections.reverse(words);
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);
Collections.reverse(words);
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.
I can definitely recommend 3) and 4) for sure. 2) has a particular style - many people enjoy it, some might not, so read a few pages first.
I'm not personally familiar with 1) and 5).
I will also add Clean Code for design patterns and general organization. If you're a beginner, it's probably okay to take that book at face value. However, once you get more advanced, you'll discover the parts where you can bend/break the strict rules he sets up there.
If you find you have too many
ifbranches, it may be a sign to refactor/reorganize that section of code. Move work to separate, nicely named methods; move branching logic to a separate method; move conditionals to methods. Perhaps throw the whole thing into a separate helper/utility class. Your goal should have your high-level code stating what it wants to do,nownot how it does it.If you're looking to improve your code readability and craftmanship, I'd suggest maybe you pick up a good book, perhaps Clean Code. I found that book really elevated my game and perception of things. I can't recommend every style described in that book; you should read it, learn, look at code in new ways, and do what makes the most sense for you and your fellow developers that you work with.
EDIT: a typo
Robert "Uncle Bob" Martin has produced a lot of good material on exactly this subject.
You could start with one of his books Clean Code: A Handbook of Agile Software Craftsmanship
He has some other books, and a website cleancoders.com
Book recommendation:
Chapter 4 is dedicated to code comments and will help you to understand why some people are talking about self documenting code.
I also recommend you to remember the books author. He also calls himself "Uncle Bob" and you will find several good talks from him on youtube. (Warning: they usually start with some minutes of a completely unrelated topic)
If you take developing software "serious" i would declare reading this book as mandatory. The same goes for his talk about "Expecting Professionalism".
Yeah, and that's largely the problem when software engineers run into "academic" code -- the conventions used are all mathematical or physics-type nomenclature, but it makes it almost impossible to read/follow for someone that's used to reading code, if that makes sense.
There's a fantastic book called Clean Code that talks about how to just write code better and in a more readable manner. It's pretty readable by people with any level of coding knowledge, and I'd highly recommend it should you ever want to cross into the realm of software as a profession, or as a more serious hobby ☺
If you're moving from academia, chances are any code you've written has been to get the computer to do something. Software development is more about writing code for other people to read and work with... which also happens to do what you want it to do. You might want to make sure you have the basics of software engineering practices down by reading Code Complete and Clean Code: A Handbook of Agile Software.
Beyond that, if you have a solid project or two that you can talk about the ins and outs of, it shouldn't be hard to convince a company that you can analyze data and write code to automate or otherwise help with that process.
He's probably talking about Uncle Bob's book. https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882/ref=sr_1_1?ie=UTF8&amp;qid=1496214502&amp;sr=8-1&amp;keywords=clean+code
There are books and articles on the subject (recommendations welcome).
A good advice is to keep in mind (or imagine) that the code will have to be changed. Maybe in a year, maybe not by you - this is very common in "real life". For example, of you have 128 of something to process or a limit of 128 that appears often, write N = 128 and then use only N, this way, if/when the limit changes, you'll have to change in one place. Keep code as modular as possible: if there is getting data, processing the data and displaying the data, keep these as separated as possible - no processing during displaying. This way, if/when you'll have to display it otherwise or somewhere else, you'll change the displaying code, but the processing will stay where it was: out of sight, out of mind.
Then there's code review, not for the faint of heart, as it's 99% negative feedback, because it lists things that need to be changed and improved and doesn't focus on the good ones. But this is very "real life": you can't get attached to your code, it will be ciritised and it will be deleted, it's a stepping stone and not a work of art. (Take pride in what the project does and the difficulties overcame. It can be a challenge to keep your head up high in this job, since you're always working on the things than need fixing, not the ones that are done and working.) If you want, you can send me a sample to review.
Finally, the appropriate xkcd.
Pieces of your app should be able to change without considerable changes to the whole.
research solid principles:
http://en.wikipedia.org/wiki/SOLID_%28object-oriented_design%29
research a layered architecture:
http://layersample.codeplex.com/
try this link for sqlite:
http://brice-lambson.blogspot.com/2013/06/systemdatasqlite-on-entity-framework-6.html
also, if you are in school, complete your assignments, but other than that
do not write another line of code until you have checked out (at least read the chapters on writing classes and functions):
Clean Code
http://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
and Code Complete
http://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670
Is there a point to doing this early? When you get an entry level position you will learn all of this and more. Also you seem to be missing a small detail. A team doesn't just consist of engineers. There will be a set of non-engineers on your team whose sole purpose will be planning, issuing work, documentation, etc.
That said:
> I would like to learn how to work on a software development team and whatever that entails.
The only place you can get this is on a software development team in industry. Much of the industry have agile processes for scrum, issue tracking, etc. but those are really to manage large teams for largely divided projects. If you are working with a couple of friends then the best thing to do is peer program when you can and code review when you can't. If you plan to make a start-up, then it might be best to get some one to do the managerial work. If you're insistent on doing it yourself, then you'll really end up spending most of the time manage the project rather than writing code, which means you're basically just a manager anyway.
But if you insist anyway, here's some books:
Read Clean Code. Uncle Bob's advice is to keep methods to around 10 lines long. The reason is that any longer than that and you're almost certainly mixing levels of abstraction and you have to keep a lot more in your head when reading the code. He advises ruthlessly using the Extract Method refactoring, but tease out abstractions as you do. Your methods should "read well", like a recipe from a cookbook, with details captured in aptly named helper methods.
That line of code you showed violates more Interface segregation principle than Single responsability to me.
It's not because everyone is using something that it is a good practice... You can try to spread the good word around you and encourage people to read or re-read Clean code for example.
I truly believe that everyone should have read "Clean Code" by Robert Martin atleast once! Hiigly recommended:
https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882/ref=sr_1_1?ie=UTF8&amp;qid=1465858366&amp;sr=8-1&amp;keywords=clean+code
Try as hard as you can to match the principles of [SOLID design](http://en.wikipedia.org/wiki/SOLID_(object-oriented_design%29). Each principle has relatively straightforward rules to follow, and you should have to justify to yourself why you need to break any of them before doing so.
Coming to terms with SOLID design alone will help minimize a lot of problems and help you think differently about writing more maintainable code, but here are some other tips:
ifblock or breaking out nested logic into their own functions/methods.Finally, check out the book Clean Code by "Uncle Bob" Martin, which goes into a lot of the above and more in more detail.
I'm self taught and it definitely is not a myth. To add to the top comment, you might want to give this a read as well:
https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882/ref=sr_1_1?ie=UTF8&amp;qid=1468420257&amp;sr=8-1&amp;keywords=Clean+code
This book?
https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
Hello,
From my experience, the tool selected for a project will always become the wrong choice after a certain period of time. It is never obvious which tool is the best at the beginning of a project. An experimented team will more likely make reasonable choices but they should always keep in mind that the tool they use will be replaced at some points or modified. That's why architecture and good coding practice are the cornerstones of a project able to withstand evolution.
I had to work, one day, on the transition from SQL to MongoDB. There is no magic, all the code calling the SQL data source had to be rewritten. It is a costly process but the final cost of the operation mainly depends on how well the calls to the database are isolated from the rest of the software.
Sadly, I don't have any tools for handling this specific case. But I can recommend those books :
This is kind of a "bible":
https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
But frankly speaking not every page of this book is worth reading imo (quite many are, though!).
I would advise to read the first ~2/3rds at least. You will understand all you need to know... And then only good amount of self-correction and practice will help afterwards.
I'm disappointed he went there as he is a really knowledgable guy that many developers could learn a lot from (even if they don't agree with everything he advocates). Specifically I think Clean Code should be a pretty essential part of any developers library.
Clean Code by Robert C. Martin.
A redditor bought me a copy as a gift, to whom I am eternally grateful. It really changed the way I code.
"Clean Code" is excellent - all the code examples are in c++ but they are easy to understand (id never used c/c#/c++ when i read it).
https://www.amazon.co.uk/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
Clean Code (used)
Or a 6-pack of 5 hour energy
Just an aside but if you are resorting to heavy use of regions and/or need to collapse methods to keep the code organized and readable you may just have classes and methods that are way too large. See Clean Code if that is the case.
Allow me to point you in this direction and here click on the link that says "Robert C. Martin", read "The Craftsman" 1-8
I think you're going to suffer too much with broad strokes. All of the things you've mentioned have their own usecases really. You should focus on one of them and learn it before deciding whether you want to try another.
Although, you can also just do 'X vs Y' for all of those things you've mentioned and see articles on the differences between them as well as what they actually do.
Before you start any of the learning on any of those things though, you should definitely take one or two JS courses. Code School, Code Academy, Udemy all have great courses on Javascript. A couple of books I'd definitely recommend are Clean Code and Javascript, the Good Parts, I'd say these are ubiquitious and essential reading for any developer looking to get better.
Less and Sass are for doing stylesheets better. They basically introduce programming concepts like functions and variables into CSS.
Gulp and Grunt are task runners. Tests, minifying, linting and live previews can all be done with them.
Angular and React are basically front end frameworks built with flavours of JS. They introduce OO concepts into javascript and the MVVM/MVC way of working for the front end. The are markedly different from how they do things.
With the other things, there's basically a wealth of information for them.
Needless to say, you have a lot of reading and practicing to do. Luckily these days there's lots of examples and documentation for every one of the things you've mentioned.
for the time out, it's usually because you are using an algorithm not optimal.
As for clean code, some of it is general to any language, and you can ready a bunch of book on the subject (like this one https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882 )
but you can also look for clean code in python in particular, follow the pep8, read the official guide https://docs.python-guide.org/writing/style/ and on top of that, maybe look for code style as used in big companies (like this one at google https://github.com/google/styleguide/blob/gh-pages/pyguide.md )
Books and when possible building side projects.
List of Java-related books I've found helpful.
Clean Code
Java 8 in Action
Data Structures & Algorithms in Java
Test-Driven Java Development
The last book (Test-Driven Java Development) briefly introduces different testing frameworks for java. It gives you a good start to work off of on your own.
Ninja Edit: I'm also adding two websites that have rather useful examples/diagrams for different design patterns.
DZone
TutorialsPoint
Most docs aren't going to tell you how to code professionally. I have found that books are the best bet for this, since they're usually composed with a story in mind. Some of these aren't going to be web-specific. But they're still really great.
For example: Clean code: https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
A general rule is that classes should represent one object (as an abstraction, not Object as in class instance), and functions should do one task, and it should be understood from name alone everything that they do. If a class is convoluted, it means you probably have more than one class pigeon-holed into a single class. Break it up into separate classes. Same for functions. If a method is too complicated, it should probably be at least two functions.
It might seem crazy to break up a 5 line function into 2 or 3 2-line functions, but you'll be better for it when you return to your code in a month and have to make sense of it again. Hell, it might help in a hour when you realize that one of the jobs performed in that function needs changed, you won't have to weed through a dozen other functions to find the line that you need to change.
Try giving Clean Code by Robert Martin a read. It is a must read IMO, because the suggestions in it will make you a better programmer overall, not just in one language or methodology.
Hahaha, you're right, my post sounds totally creepy, sorry about that.
What I got from you is that you're basically dealing with 2 issues:
Lack of knowledge, skills and experience: it's like you have 4 times 1 year experience instead of 4 years of experience. Seems that you miss being exposed to different challenges and solutions to those challenges.
Imposter syndrome - fed by the previous one
First, it's important to acknowledge that both these problems will follow you throughout your whole career. The very nature of our industry, whit new tools, languages, frameworks and techniques appearing litterally everyday, makes it impossible for someone to know everything. Given this scenario, we have to be smart about what and how to learn things and, at the same time, be confortable being unconfortable.
I think those are a whole new discussion (we can talk about it if you want) but I'd like to suggest some tactics that might help you on a shorter term:
Join a community
This was what made THE big difference for me years ago. I didn't know anything other than what I did at my job; the community showed me different ways of doing my work that I didn't know even existed. It's a perfect space to learn, share experiences and network. Try to join a local community that has in person meetings. I still get a lot of energy from interacting with people from outside my job.
Pair programming
I don't know if your team does pair programming, but I'd recommend it. Even if you team doesn't do it, ask people if could pair with them for an hour or so on their tasks. Learn their style, how they use their tools, their shortcuts. Ask what they're thinking as they code. Discuss the solution being implemented, talk about alternatives.
I think pairing is one the best ways to learn.
Good article about techniques for pair programming by colleagues of mine
Start a pet project
Assuming you lack experience on backend development, I'd suggest you start building a complete web application on your free time. Build something that you care about and would actually do something, so you stay motivated. You can start with something very simple and add features as you go.
I don't know if you're interested in some specific language/technology and I don't know what your team uses on your current job (it would be nice to practice on something that would be immediately useful on your job), so I'd recommend something like Rails. Rails can be simple enough for a beginner to see progress quickly and has a huge community for support.
This app can be your platform to learn and practice a complete software development lifecycle for a typical web app - stuff like OO design, HTTP and REST, MVC pattern, unit testing/TDD, integration and functional testing, version control and how to deploy and operate a system in production.
You can share your code in GitHub and ask for reviews and feedback.
Teach
There's always someone that knows less than you do about a subject. Offer help on the communities you're part of, answer questions on reddit or stackoverflow, coach a new teammate... there are tons of opportunities. Teaching will make you feel good about yourself and will help you to reflect and understand more deeply the subjects you're teaching. Confidence + knowledge.
Host a lunch & learn or brown bag session for your team/company. You could share interesting stuff you're working on, cool technologies for your team to try or any other tech related subject. This can make you be perceived as the "go to" person on some subject and as someone who's making an effort to learn and share with coworkers, bringing lots of value to the team/company.
Books
I strongly recommend you check out Clean Code and The Pragmatic Programmer. There are many other great books I could recommend but those two were the ones that changed the way I see my profession.
I can think of a bunch other tactics to help you improve your skills and confidence, but I think this is enough to start a conversation.
Ideally, our jobs should provide all the opportunities to practice and accomplish all the things I suggested you do by yourself. But to get one of those jobs, we need to take the firsts steps. My point is that we should be in control of our career, not your manager/team/company. If we want to learn something, or use some tool or technology, we shouldn't wait for the opportunity to come.
Does this make sense to you? Is this helpful?
PS: I'm curious about a couple of points:
When you say "I've always struggled to build big features", what kind of features you're talking about? Can you be more specific?
When you say "I have to spend a really long time just thinking about some problem", what kind of problem is this?
I might have some insight about those issues.
It is good practice to have variable names with clear naming that accurately describes what they are for. What you're suggesting results in variables with absolutely no name whatsoever. (array[0], array[1], array[2] are hardly descriptive).
Moreover, good programming means dissecting your problem into small easily managed chunks. So small, clear functions or objects. If you have a lot of variables in these, you are doing it wrong.
https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
What about some classics like Uncle Bob talks?
A lot of good design focuses on decoupling and creating components which work together but separately also.
Id first look into language agnostic design principles such as SOLID
https://youtu.be/TMuno5RZNeE
https://youtu.be/zzAdEt3xZ1M (golang)
A good book will help.
https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
I still keep a copy of the Gang of Four book at arms reach even tho the popularity is dwindling as OOP is not topic of most convos today. However when dealing with DI and sharable components in Golang, i find myself still falling back to abstract factories patterns. Its a good breathe of knowledge to at least glimpse at the patterns here:
Design Patterns: Elements of Reusable Object-Oriented Software https://www.amazon.com/dp/0201633612/ref=cm_sw_r_cp_api_i_7BzvDbXJC5WS4
Once you get thru these topics, you can start picking up what I consider the "hot" architectures of today:
Microservices, event based systems, domain driven design, event sourcing, and architectures aiding themselves to functional programming.
I really enjoy reading Martin Fowler blog posts: https://martinfowler.com/tags/application%20architecture.html
He covers a lot of these topics.
PS: maybe a niche and a personal favorite of mine but ive learned ALOT by researching the different types of kernel architectures. Nothing really geeks me out like those topic, but not for everyone.
A fabulous free course exists on these topics:
https://www.udacity.com/course/advanced-operating-systems--ud189
Read Effective Python and Clean Code, in that order.
A lot of the tips, including this one, come from Uncle Bob's "Clean Code" book. I recommend picking it up for a much more thorough examination of Clean Code principles. https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
There are times when a 4 line restriction on function length is burdensome, but it tends to be a good guideline. Language also matters. I've found it's harder to adhere to the 4 line restriction in Node than PHP for example just based on typical syntax for the language.
At first, just code. Your code will suck, but it's okay because you're learning.
Then, once you have a good grasp of programming, read
http://www.amazon.com/Refactoring-Improving-Design-Existing-Code/dp/0201485672
And
http://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882/ref=sr_1_1?s=books&amp;ie=UTF8&amp;qid=1397498858&amp;sr=1-1&amp;keywords=clean+code
You can probably find them for free online.
From the book: http://www.amazon.ca/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
Do not comment the hell out of your code. Well written code should be self explanatory. Do not comment what, comment why.
Read this book:
Clean Code: A Handbook of Agile Software Craftsmanship (Robert C. Martin)
What you have to realize is that framework is a tool for development. It lets you code pages faster, by already have done the "mindless tasks" (like creating user authentication or routing the requests) and letting you focus on the parts that matter.
But there is a cost - performance. Unless you really suck at writing code, framework will make you application slower, because of all the generalization and "works for everyone" approach.
If you have an existing site, just slapping on a framework will gain you nothing. If you want to rewrite you application from scratch, then framework will let you complete that in less time (if you already know how to use said framework).
If instead you want to expand or optimize the existing functionality, you should focus on refactoring and profiling your existing codebase. If that is the case, here are few books which would help you with it: Clean Code: A Handbook of Agile Software Craftsmanship by Robert C. Martin , Real-World Solutions for Developing High-Quality PHP Frameworks and Applications by Sebastian Bergmann and Refactoring: Improving the Design of Existing Code by Martin Fowler. Said book will not give you clear rules for "how to do this", but instead will explain you the direction in which you should aim.
---
P.S. in my personal opinion , CodeIgniter is one of the worst php frameworks out there, with unreasonably high popularity.
Writing bad code is fine when you're starting out, but being able to write code that you and others can read after it's complete is not an impossible feat for a beginner. To get a start in writing good code, read Clean Code. I would suggest reading it after your (/u/Zeno_Zaros) first semester when you have some idea about programming.
I'm by no means an experienced programmer but one of the books I have queued up to read which is recommended in the sidebar and many threads is Clean Code: A Handbook of Agile Software Craftsmanship
From one of my favorites books, Clean Code: A Handbook of Agile Software Craftsmanship:
> Others who see that commented-out code won’t have the courage to delete it. They’ll think it is there for a reason and is too important to delete. So commented-out code gathers like dregs at the bottom of a bad bottle of wine.
Clean Code
Refactoring into Patterns
Both talk a lot about them but do not enumerate them authoratatively.
Any day!
If you read Clean Code, the author, Robert Martin, goes so far as to suggest wrapping ALL third-party libraries (See CSharpSharp). This is so, should you choose to switch libraries, you only have to change your wrapper and not every place you called that library throughout your entire application. By the time you've written wrappers around this trivial library, you might as well have written it yourself.
This code is provided with out warranty, as per the GPL. Should the project lose support, or a rouge developer makes a check in, your only choice is to fix it yourself. At that point you might as well rolled your own and open sourced it. (Note: even if you fix the OSS library, if the project creator has abandoned it and you don't have write permissions to it's sourcecontrol, it's like you wrote it yourself.)
EDIT: Spelling and punctuation.
This is the third book suggested that was written by Uncle Bob.
Can you maybe explain the Difference between:
Clean Code , Clean Architecture and Clean Coder. All books by Uncle Bob
Hey! I'm not a senior or something but I have a tip for you (might sound a bit contradictory to what you've been learning in school/uni). I would try to cut down on the comments.
A lot of your comments are just restating exactly what the code says. For example
//Create an array of four structs - one for each tax band
struct taxBand taxBands[4];
Everything your comment says is already said by the code itself. The comment thus does not add meaningful information and just clutters up the code.
Even worse, you add maintenance problems to it: if you have to change the code in the future (let's say we get a new tax scheme and now there are 5 tax brackets), you have to change the code AND the comment. If you forget this at some point (happens easily), the comment will now even give wrong information about the code.
Generally, try to use comments not to describe code, but to describe your intention or very tricky parts about your code. You can also refer to the Google Code Styleguide if you have further interest. Clean Code also has a good segment about it.
The rest seems fine. As an additional exercise, you should probably try not to hardcode going through the taxbrackets, but try to write it in a more general way. At the state your programm currently is, if new tax brackets were added, you would have to write (copy-paste) additional for-loops as you did in
//If the income is more than the upper limit of band 1, but less than band 2, work out how much income is taxable and multipy it by the band 2 tax rate. Add the result to the tax variable
else if(income < taxBands[1].upperLimit){
tax += (income - taxBands[0].upperLimit) * taxBands[1].rate;
}
You can try to rewrite that section so it does not depend on the total number of tax brackets :)
If you have questions, feel free to ask!
Good job! Copying existing game ideas is a perfect way to learn
Some recommended reads I had saved as bookmarks if you want to dig even deeper into game programming:
Game programming patterns
Goes deep into all the different patterns of writing a good game engine. Written by one of the devs at EA. There is a free web-version if you scroll down on first page.
Game mechanic explorer
Lots of small snippets and explanations on common mechanics, like bullet trajectories etc. Only for 2d games but much easier to digest then the patterns-site.
A* introduction
A* is a fun algorithm to implement
Clean code book
This one is a must, a book you might get the most out of when working with other people but if you wanna get thinking in the terms of maintainable code and what will be expected of you at a real workplace, take the advices it gives to heart :)
And a tip for a potential next project:
One of the first games I did was a clone of Bomberman. The graphics can be pretty simple but you get to dig into cool stuff like (simple) AI with pathfinding and you can make a very simple multiplayer game out of it that isn't that lag sensitive
https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
Maybe check the clean code handbook. Already the first pages describe what many people do wrong which leads to crappy code. You can also find it on the interwebs.
https://htdp.org/2018-01-06/Book/
https://mitpress.mit.edu/sicp/
https://mitpress.mit.edu/books/introduction-algorithms
https://www.amazon.es/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
https://www.amazon.es/Object-Oriented-Design-Heuristics-paperback-ArthurRiel/dp/0321774965
https://www.amazon.es/Design-patterns-object-oriented-professional-computing/dp/0201633612
In one year you will be properly equipped to look for a professional position :)
>How valuable is an Oracle cert?
No more than any other online course from a respected institution such as google, say: https://cloud.google.com/training/free-labs/ or one of the online courses available at MIT/Stanford.
>What else should I look into to boost my repertoire?
See if your university has any business partnerships you could do a 2-3 month project for. I worked with one of the university's here in the UK as part of a business/university partnership and that gives the students real world experience and us some free work. Win-win if the project is completed.
Sorry - mostly UK (amazon) links :)
TDD - https://www.amazon.co.uk/Growing-Object-Oriented-Software-Guided-Signature/dp/0321503627/ref=sr_1_1, Video by Trisha Gee whos fairly well known for speaking on this stuff: https://www.youtube.com/watch?v=QDFI19lj4OM (some very handy shortcut keys in the video and a good outline of some of the tools available to you).
Clean Code - https://www.amazon.co.uk/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882 (by "Uncle Bob")
Design patterns - https://www.amazon.co.uk/Head-First-Design-Patterns-Freeman/dp/0596007124/ref=sr_1_1
Learn to use shortcuts in Intelli J to speed up your ability to generate/refactor code: https://www.amazon.co.uk/Getting-started-IntelliJ-Hudson-Assumpção/dp/1849699615/ref=sr_1_1
Also Jetbrains does good newsletters (curated by the same lady that made the video above under TDD) sign up to stay up to date with interesting/relevant blogs/articles/industry news https://www.jetbrains.com/resources/newsletters/
Github - https://www.amazon.co.uk/Version-Control-Git-collaborative-development/dp/1449316387/ref=sr_1_4
Bash Commands - https://nikgrozev.com/2016/05/22/shell-cheatsheet-part-1-common-bash-scripting-tmux/
XP/Scrum/Kanban development process - https://www.agilealliance.org/glossary/xp/ the way we work
Trusted developer blog on various engineering topics https://martinfowler.com/
Interview Prep https://www.hiredintech.com/courses
Hint: the above books are likely to be available at any academic library. If not, request them. you likely only need to read 33-50% of them and you'll be golden. I imagine you can likely get hold of electronic versions of these books as well.
The best thing you can do to prepare yourself is to start practising developing projects... get them up on github. it could be a website, a desktop application/game/tool, a demo of sorting algorithms, a web service... literally anything. Fork others' projects, code a feature request and create a pull request back to the original repository/codebase on github. Just build something rather than nothing. Anyone can do the latter. There's so much more opportunity now that we have github available. Think of any thing you might be interested in working on and someone, somewhere has likely already got a project underway in that area, and you're free to submit a pull request to their repository at the click of a button. This wasn't really possible 10-15 yrs ago.
The simple answer is there's so much to know, you just have to find what your interests/passions are and follow those as much as possible.
No matter how good you are at what you do today, the tools will be different tomorrow and may even depend on the industry you enter: AI, web services, blockchain, computer vision, robotics? The list is long and each one requires you to be highly trained (over many years) before you're considered any good at it.
Just try to learn what you can. Find something that genuinely interests you and study it until you become a trusted authority on the subject, or you find something you're more interested in instead.
If you have any ideas for the type of area you might be interested in put them up here and perhaps someone can point you to a relevant project?
https://en.wikiquote.org/wiki/Howard_H._Aiken "Don't worry about people stealing your ideas. If your ideas are any good, you'll have to ram them down people's throats."
I just chose some books that looked good from this list and this one.
The one's I got:
Clean Code
(already read)
Cracking the Coding Interview
Code Complete
Peopleware
Don't Make Me Think
Code (currently reading)
Regular Expressions Cookbook
Head First Design Patterns
C++ Primer
Working Effectively with Legacy Code
Elements of Programming Interviews in Java
The Mythical Man-Month
The Design of Everyday Things
JavaScript and JQuery
I figure that's enough reading material to last me until I graduate.
Please consider reading this 😉
I know you are the sole developer but still...that is just confusing.
There are more than 356 people in the programming community. This isn't Mumps.
I agree most of the time that early returns are better. But this isn't proof that "most of the programming community agrees". You realize that there is a substantial amount of developers who believe in only 1 return per function, right? Something that is evangelized in Clean Code.
Not really related to mobile development, but he should still really enjoy these if he hasn't read them already:
First of all, applause for the great start.
Here are some criticisms/suggestions I would like to offer. Keep in mind, I am not assuming your level/experience as a software developer:
> I force myself to write raw SQL Request to get better with SQL
while that is commendable, it is not really a good idea to write raw sqls in production code if there are ORM library alternatives available. Remember, it's not always you that is going to read/modify the code. While ORM syntax will be fairly universal, your style of writing SQL may vary starkly from other people - which is what creates confusion and lets errors sneak in. Even if you want to do that, maybe keep the raw sql in separate modules (point 2).
Finally, remember that all these are just suggestions, and you may already know them. You will decide which ones to take and which ones to leave behind based on your situation.
Again, great job (I also learnt something from this). Just make sure you keep running.
This book changed the way I did things massively and may help you:
Clean Code: A Handbook of Agile Software Craftsmanship (Robert C. Martin) https://www.amazon.co.uk/dp/0132350882/ref=cm_sw_r_cp_apa_i_lxCwCb8S1W5DZ
So I feel that it's worth pointing out that the linked article was written by somebody who apparently is (was) associated with a company that sells testing services. Keep in mind that they might not necessarily be a neutral party.
I could just as easily link you to Working Effectively with Legacy Code or anything written by Kent Beck. They too can write many words to try to convince you that they know what they're talking about.
Having said that, I do agree with many of his points, though I disagree with several as well. The problem I have with that paper is that his points don't prove his conclusion, and definitely don't support your argument. I mean, some of his points are:
And I pretty much agree with all of those (though the third one, while true, is completely unhelpful). But to jump from that to "and that's why unit tests are basically worthless" is making quite a leap.
Unit tests are a tool. They're particularly well suited for testing algorithms. For example, suppose you had to implement
sqrtyourself. Yes, I know that you don't have to, but there's some application-specific algorithm that you had to implement at some point. Since I don't know your application, I'll just pretend that you had to implementsqrt. Having a table of well-known inputs and outputs forsqrt, and verifying that your implementation produces results within some epsilon of those known values, is obviously a good idea. And checking thatsqrtworks on its own, outside of your vertex transformation code (because the application that I'm thinking of is a graphics engine) is obviously a good idea. And this is the textbook example of when you would use a unit test.But unit tests are just one tool. There are some things that just aren't worth testing, and there are things that make no sense to test at a unit level. But those two statements don't refute that unit tests are perfectly appropriate to a large range of problems.
I mean, if you've already decided that you will not write unit tests, then there's nothing I can say to convince you otherwise and there's no conversation to be had. I'd be much more interested in discussing when it is appropriate to use unit testing, and when it's appropriate to do something else.
Learn about "characterization tests." Also, read this book.
I feel for you OP. I recently inherited a fully functional system already in production that was horribly coded. It is now in very good shape, and with a 92% test coverage. It is possible OP! ;)
Yes definitely create the UML diagrams. When you understand it well enough to create a high-level diagram, you will be much better armed, both for making changes, and for showing outsiders why A and B are important to do, since you have something concrete to go from. I would recommend this UML editor for it.
Next, is the code sufficiently under test?
If not, buy and use the book Working Effectively With Legacy Code by Bob Martin. It helps a lot. First step is getting at least some of it it under test. The book is a big one, but you don't need to read it all to get cracking. It is like a recipe book:
"Let me see, okay, I have eggs, chicken, and a 1000+ lines class calling into an unknown legacy system. Then I should use the coding recipe on page 432, and plenty of garlic. Always use plenty of garlic."
Best of luck OP!
This doesn't seem as much of a defense as a lack of knowledge/experience/vision(creativity).
There exists methods (processes) and ways to architect that may be applied to even the most complex domains. There are innumerable papers and books on this subject. "Working Effectively with Legacy Code" (http://www.amazon.com/Working-Effectively-Legacy-Michael-Feathers/dp/0131177052) is decent start as any.
Btw, OOO, state machine, data-driven code, abstraction layers are the methods I'd be likely to investigate given OP description of 1500 line network function.
P.S. language and tool choice is very important. Some lack the power to easily express anything better than spaghetti.
P.P.S There are actual defenses of "Spaghetti Code" or rather why not to refactor or write crap code in the first place. One is YNGNI, e.g. prototype, time (startup needs to ship early to survive till critical mass when it's all getting thrown out anyways). Like everything the cost/benefit needs to be evaluated.
The Working Effectively with Legacy Code book is fantastic for bringing legacy code under test and then being able to refactor from there without breaking functionality.
Around 80-90% of the examples in the book can apply to ruby based projects with the remainder being C/C++ or other language specific problems (header files, being an example).
Just as important as the techniques explained in the book is the philosophy it espouses of bringing the code under test.
There are a lot of answers to your question. From the very question you're asking, I already know you aren't doing much unit testing. Unit tests are one of the most powerful forms of documentation you can have, because they document the expected behavior of a module. Code without unit tests is legacy code, and unit tests will help you tame that.
Help. They are not a panacea. And don't let "you should start unit testing" turn into "we should start tracking code coverage metrics". But unit tests can add a lot of value.
For unit tests to add value, you also need to have some sort of automated build process. Most build systems will have an easy-to-enable continuous integration mode. Turn it on. At first, your builds will fail. A lot. Especially as you start adding tests. But over time, those red lights are going to get less and less frequent.
Now, what are you doing about managing changes to the application? What's the workflow for putting things onto the backlog? How do they get prioritized? How do people get assigned work? There's no right answer to any of those questions, but I have one big piece of advice: don't let anyone own a module. If Sallybob was the last person to touch the OrderProcessor, the next time it needs a change, give it to Joebob. Yes, you're going to take a small hit on your cycle time. It's worth it.
I totally don't understand what everyone's issue is. My favorite thing to do is to refactor legacy code and my bible for doing it is Working Effectively with Legacy Code. I get a huge amount of satisfaction from turning a complete mess into something magnificent and the best part is that it can all be done with minimal risk.
Been down this road and finally started having it make sense a couple of months ago. Try as i did to be better at testing it always felt like a hassle until i shifted my focus to writing testable code.
With that in mind, aside from covering basics of writing tests:
Injecting an interface that does nothing but provide DateTime.Now seemed absurd and overly complex when i first read about it but once all those pieces came together everything finally clicked and i no longer hesitated on writing tests as they were no longer difficult to write.
I've been meaning to read through Working Effectively with legacy code but from what i have read so far it seems to have a huge focus on making old code testable, perhaps an option if your looking at improving your code base in your current job.
I'm still a young C# developper, around 3 years of C# for websites and APis for small and big companies, but it's not because your predecessors built an in-house framework that this is the right way to build a system. C# is a great language but it shine thanks to the core orientation of productivity delivered by the .NET framework and ASP.MVC.
Of course if your needs are so specifics that you want a custom framework, don't forget that it will become a HR problem. Talented people rarely want to jail themselves to a company and build a specific set of skills that can't be transferred.
But as I said, I'm young. I do think that we are living on the shoulders of giants and that not everything need to be rebuilt. Some of the coolest techs we've seen these past years around containers and micro-services were actually already implemented in the 70's.
That said, I didn't read this book, so I will read it and predictably learn a lot of things. If you didn't already, I would recommend the following books. They aren't C# specific but will help you in the environment you are describing:
A mountain of pattern for common uses cases to improve stability and efficiency of legacy apps.
(https://www.amazon.com/Phoenix-Project-DevOps-Helping-Business/dp/0988262509/ref=sr_1_1?ie=UTF8&amp;qid=1498813798&amp;sr=8-1&amp;keywords=the+phoenix+project)
An inspiring guide on how to work and migrate from waterfall project toward a more predictable project management methodology.
No "Working effectively with legacy code". Which could be titled "Pragmatic testing".
The DDD blue book, ok. But you'd be better served with "Implementing Domain-Driven Design" which was written 10 years later and have a lot less focus on the technical implementation of DDD.
Mastering Regular Expression should be there too.
try to apply principles from Working Effectively with Legacy Code as you work through your tasks
In terms of practical, professional skills, here are a few I would recommend:
For more tailored recommendations, where do you feel that you're weak? There are plenty of college textbooks that can introduce you to algorithms, but if you have an end-goal in mind, you can really focus your learning. Work on some tougher projects than you're used to, and study open source code that does interesting things.
I think it would be a good exercise to learn something new and then go back to your old projects and apply them. For example, learn about testing and go back to your calculator and try to get a good chunk of it under tests (another good resource is Working Effectively with Legacy Code, which covers getting projects under tests when they don't have any). Then learn about CI/CD, which use tests, and make a build pipeline for your calculator. Then read Clean Code, read about architectures and patterns, and see if you can improve your architecture. This is just an example, but any of those could give you good talking points if interviewers ask about your projects.
Idk if there is a name for this, but it is a well-known phenomenon, to the extent that it killed companies (Netscape anyone?). The proper way to replace legacy systems is to refactor and evolve them (eg. by splitting out services from a big monolith one by one), not trying to replace them in one big go.
I was told Working Effectively with Legacy Code is a very good on the matter.
I've enjoyed Working Effectively With Legacy Code by Michael Feathers.
It is an excellent survey of techniques for breaking up monolithic codebases into independently testable modules. He's a strong advocate of test driven development, which I would argue is rather critical to you successfully redesigning your application.
You can. These are called pinning tests. They're usually done over small parts of the code, like a single function. You pull out a bit of code into a separate function, write tests so every line of the new function is tested, and repeat.
Once the section you want to refactor is pinned down, you can change to your heart's content without fear of introducing regressions.
You should read Working Effectively With Legacy Code by Michael Feathers if you haven't already. It changed the way I approach writing code.
True. I can highly recommend reading Working Effectively with Legacy Code by Michael Feathers.
You might find Michael Feathers Working Effectively with Legacy Code useful. It demonstrates how to safely migrate towards TDD in legacy projects by building up automated functional tests which allow safe refactoring to more testable code.
Doesn't answer your question . . . but get this book. It sounds like it would help.
It is normal :) I've read somewhere that 20% of our work time we develop new code and 80% new simply maintain the old code. And after a while it sound like true :)
I've been in a situation like you. I've been assigned to maintain a 0.5 million line c++ code base with no tests and no previous maintainers.
Considering that most of the time you're going to spend maintaining your/someones code base, code refactoring, modernizing practices are very valuable. And right now it seems like you have a chance to learn to do so.
Personally, what really saved me was this book: http://www.amazon.co.uk/Working-Effectively-Legacy-Robert-Martin/dp/0131177052/.
So I believe that working on your project is one of the paths you can become a better software developer :)
About the refactoring:
Working Effectively with Legacy Code is a bible for refactoring. The single best thing I read about working with legacy shit I have ever read. It really helps.
Great book. After reading it I even enjoy working with shitty code from time to time!
> but from what I remember during my time at the company the frontend was pretty rough. The work needed to get it into a state where you could slot "labs" features in a forward compatible way would have likely been a tremendous re-write on its own
but there's proven methodolgies for dealing with giant balls of mud and untested/undocumented legacy code. (I'm partial to this one
First, make sure you have a reproducible environment. Then right a bunch of tests. A BUUUNCH. It's unglamorous, laborious, hard work, but it's necessary to make sure your changes don't break anything. Then you use a combination of heavy refactoring + abstraction, et voila.
I've fixed legacy software, from a Uber-clone that bought a template from a team in India (no shit, the code has references to "UberForX") and having to replace every part piecemeal over months, to re-writing financial services spaghetti code that was doing over a million a year. The approach never really changes.
The book that helped me most coping with legacy applications: Working effectively with legacy code
Read this book.
Then, after reading the whole thing cover to cover, start working on your proposal.
From some of the questions you're asking about jQuery integrating with a framework, it's clear that some more basic concepts of how to isolate legacy code and migrate piece-by-piece would be very helpful.
Also, just a suggestion, but I'd highly recommend doing the new development in TypeScript. It'll compile to play nice with any other code you might need it to, but will offer you some awesome tooling that will help in maintaining your project moving forward.
I've read almost all the books on C. I think you can get by with just:
This is by no means a beginner book, but it's one you might want to pick up as you progress. It is excellent ...
https://www.amazon.com/Expert-Programming-Peter-van-Linden/dp/0131774298
If you're looking for a good book I recommend Expert C Programming.
Expert C Programming : Read this after reading K&R C book.
Programming Pearls : Excellent Book
Algorithm design manual : Read it after CLRS.
Yes, that is required C reading.
Also Expert C Programming, which is actually funny at times.
Then I hear C: A Reference Manual is the last C book you'll need after those other ones, but haven't gotten to it.
Peter van der Linden's Expert C Programming (Google Books, Safari) is a good resource on this question, though it's slightly dated and undoubtedly not the whole story.
Yes. Got every answer correct, with correct explanation.
There are a few very, very good books on this topic I can only suggest everyone to read:
Start with Spring Roo + Clean Code:
Design a simple todo list or something else you can use and then get creative from there to learn new concepts. Make sure you do not just follow examples; apply them.
Use the following to expand your skills for specific situations:
Use the following as a reference for open source Java tools
Read the following sites daily just to keep your awareness open to new ideas and trends:
Your training wheels are off at this point and you are ready to move into the Java landscape with confidence.
I have been coding Java since you were 1, so trust me on this...
EDIT: Taking a class in programming would not hurt you, but you will move more quickly and more directly outside of classroom, so do both. Give preference to the learning outside of the classroom, as it will invariably be more practical.
The Pragmatic Programmer.
By far, this is the best programming book I have ever read. It discusses programming and software design strategies that are completely language independent, and were rarely discussed in any of my classes.
I wish whoever wrote the legacy code I currently work with had read this book.
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.
The Pragmatic Programmer is in my opinion the best book on "etiquette". My first boss in the games industry bought it for me and told me to read and absorb it.
Large Scale Software Design was the book I read about large scale structure, but I think it's kind of out dated if you ask me.
I would suggest reading these books:
Each of these books covers a different major topic. In order: practice of programming, theory of programming, and theory and practice of being totally awesome.
To je čest anti-pattern, dovedu se fazani da održavaju stare projekte da bi stare iskusne kuke Pravile Novo. Keč je što su fazani po prirodi stvari nespremni za tako nešto. Zasuti nekoga ko je do tad radio samo na sintetičkim fakultetskim projektima gomilom real life legacyja je ... upitna praksa, ali nije ni skroz glupa pošto je to bitan deo realnog programerskog života. Kako kaže onaj kliše: "prvih 10 napisanih linija su greenfield projekat, sve preko je legacy kod". Sve što te ne ubije te jača. (F. Niče)
Ako nemaš živog mentora, ili ti je mentor go qrac, ovo je verovatno sledeći najbrži put do sledećeg nivoa: https://www.amazon.com/Pragmatic-Programmer-Journeyman-Master/dp/020161622X
Knjiga jeste malo outdated po pitanju tehnologija, ali su principi i saveti odande svevremeni, dobri, i večiti.
What are your 3-5 year goals? You don't have any code experience, do you want to gain some broad computer science/ programming chops or are you after SF specifically? What happens if SF falls out of favor, what do you want to be your secondary employable IT skill? Things to think about as your starting your journey into programming.
Regardless of your goals, I would encourage you to learn some additional languages/ paradigms than SF. I can't stop suggesting cs50, it's a world class intro to computer science.
Without filling in some more of your broad coding chops and learning best practices it will become at increasingly difficult at some point to continue to 'level up'. Understanding the design patterns/ strengths and weaknesses of other platforms will give you additional insight into what's good and bad in SF, what to lean on and what to mitigate.
What are your motivations for going into dev? Is it the work? The pay? The different role on the team? Job prospects?
What worked for me:
More than anything else, I wrote a lot of code. I wrote code to solve small problems, I wrote code for production. I volunteered with a local nonprofit. In all I tried to get in 1 hour of practice going from requirement to completed solution (with tests!) each day, with the keyboard in front of me. Preferably that 1 hour was spent on something that I would get to a MVP and would actually be used even if it was only ever by me.
Things I would suggest:
My goal has been to fill in a solid base of CS underneath me, that will be helpful with SF and many other platforms down the road.
A few that are only relevant to specific languages or niches:
Buy The Pragmatic Programmer, read it from cover to cover. Let it change your life. It's not a specific language reference but it's pretty much required reading for any new programmer. It's about creating maintainable code, which is more of a mindset than anything, it's also a really really EASY and relatively entertaining read.
https://www.amazon.com/Pragmatic-Programmer-Journeyman-Master/dp/020161622X/ref=sr_1_1?ie=UTF8&amp;qid=1520232423&amp;sr=8-1&amp;keywords=the+pragmatic+programmer&amp;dpID=41BKx1AxQWL&amp;preST=_SX218_BO1,204,203,200_QL40_&amp;dpSrc=srch
Another more specific book to use as reference is the Effective C#:
https://www.amazon.com/Effective-Covers-Content-Update-Program/dp/0672337878/ref=sr_1_1?s=books&amp;ie=UTF8&amp;qid=1520232641&amp;sr=1-1&amp;keywords=effective+c+sharp&amp;dpID=51ga39m0W5L&amp;preST=_SX218_BO1,204,203,200_QL40_&amp;dpSrc=srch
They make "Effective" books for nearly all popular languages, and they really are great references. If you don't understand everything in it like co-variance and contravariance google as a lot of good examples of these concepts in practice, as well as definitions. Believe me I understand that these things can get really confusing and frustrating coming from a non-academic background and trying to bridge that gap. But utilizing this book and understanding the lingo will also help you to find more answers to run on your own.
Now, as with anything in programming, the point is not to have to remember everything all the time in these books(despite what try-hard programmers on the internet will tell you). That comes with experience and you're human so don't set yourself up with that expectation. Read them once so you know what is in them, and keep them at your desk for reference.
When you need to construct an interface pull out the book go to the interfaces and give it a glance over to give you an idea on where to go.
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!
In no particular order:
Structure and Interpretation of Computer Programs
Code Complete
C Programming Language(K&R)
The Pragmatic Programmer
The Mythical Man Month: Essays on Software Engineering
Introduction to Algorithms and/or Algorithms
The Pragmatic Programmer. Here is a quick ref that gives a good overview of the contents.
Hi Sherlocked_
Congratulations on already having an application in the app store. That is a huge accomplishment. Also the fact that you have realized your code wasn't perfectly designed is a really good sign.
My advice for you is to just keep writing those applications. Every single one you write will become a little bit better.
This will happen to you:
Either a bug will come up in your system or you will want to implement a new feature.
When you attempt to fix bug or add feature, everything will break, or you will notice that you are making tons of updates when it should have just been in one place. Each time you do this, you will learn and the next time you are developing a piece of code that follows a similar design pattern, you will know just what to do.
At the end of the day, experience is primarily all that separates the good developers from the bad.
One of my favorite books is The Pragmatic Programmer. https://www.amazon.com/Pragmatic-Programmer-Journeyman-Master/dp/020161622X
Hope that helped!
Exactly the books many people suggested !
Further they recommended me this
My advice. Read this book Pragmatic Programmer
Changed the way i view programming. It is tough to work on a project (especially in a group). This book, written in the 90's, speaks so much truth even in our world today.
[The Pragmatic Programmer: From Journeyman to Master](http://www.amazon.com/Pragmatic-Programmer-Journeyman-Master/dp/020161622X]
It is obviously aimed more at programmers, but if you keep an open mind you will find a large number of lessons that applies to system administration.
The Pragmatic Programmer: From Journeyman to Master
Programming Language Pragmatics
XNA 4.0 Game Development by Example: Beginner's Guide
The Mythical Man-Month: Essays on Software Engineering
3 books for the summer:
... Aw I'm a nerd!
Essential reading:
http://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882/ref=sr_1_1?s=books&amp;ie=UTF8&amp;qid=1426600164&amp;sr=1-1&amp;keywords=clean+code
http://www.amazon.com/Clean-Coder-Conduct-Professional-Programmers/dp/0137081073/ref=sr_1_2?s=books&amp;ie=UTF8&amp;qid=1426600164&amp;sr=1-2&amp;keywords=clean+code
http://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670/ref=sr_1_4?s=books&amp;ie=UTF8&amp;qid=1426600164&amp;sr=1-4&amp;keywords=clean+code
http://www.amazon.com/Pragmatic-Programmer-Journeyman-Master/dp/020161622X/ref=sr_1_5?s=books&amp;ie=UTF8&amp;qid=1426600164&amp;sr=1-5&amp;keywords=clean+code
To try to answer your question about how to pick up programming concepts.
I'd say there are two parts:
It is also very useful to learn about things like object oriented programming. A huge help will be reading some code from relatively simple projects and trying to understand why it's written the way it is. You can often find open source projects and read their code and try to understand why they did things a certain way (although a fair warning, there is plenty of bad open source code out there).
There's no substitute for practice though. Build things you need. If it is at all possible, get your code reviewed by someone more experienced (I will volunteer to review some stuff if you post it to github or somewhere like that, although make sure you aren't posting code from your work that your employer owns).
One final point - I try not to be prejudiced against languages since really what makes a software engineer good is the ability to solve the problem in a maintainable way and you can do that in most languages, but you should know that VBA has a certain reputation since most people who use it were just scripting some extra stuff for their excel file.
I'd have to agree. Start touring around for tutorials like Khan's or Codecademy, and pick up some books like the Pragmatic Programmer and expand your knowledge base. You can't make it as a business yet - no offense, you're just very outclassed with the massive amount of web developers and designers out there right now.
One of the best things to do is read what other programmers have to say. It opens yourself up to things that you might not normally come across. Schedule a time of the day where you will go on Stackoverflow to answer questions or read answers. Also in that time, read some blogs and any new articles. A few of the websites that I really like:
Have you caught up reading the classics when it comes to software development? A great list of them can be found here. A few that I have found totally eye opening:
Also, have you used any new technology lately to make something cool? Schedule a time everyday (similar to when you read new things) to work on a project no matter what. Close Reddit, close your email, and get programming! Here a few things I had on the top of my head:
Hopefully all of these can give you an idea of how to improve.
Accelerated C++ has exercises. I'm partway through it myself and I think it's a great resource, particularly if you already know how to program. I'd recommend it :-)
It was released before the C++11 standard came out so doesn't contain any discussion on modern C++ features, so I'd also recommend continuing your learning beyond this book.
I recommend this book for python (It's big and fat and drills it all into your brain through repetition)
The Django and python websites have great documentation as well
this for Javascript (it's a classic)
www.jquery.com has great documentation as well
this for PHP (Rasmus is great)
this for C++ (they say it's outdated but the concepts still apply)
I love this book. It's the perfect starter book.
I like this book for C++ if you want to learn C++. Python is easier though and most people start with Python. I like the book Learn Python the Hard Way (it's actually a pretty easy book lol) but there are quite a lot of books that are good for Python. (and I'm like 99% certain there are free versions of these books available on the web)
That's probably a good way to see if you like coding. Personally I love it 'cause it's a lot of problem solving, and then forcing a computer to do your
evil biddingwork.Then for the chemistry part. I think everybody on the planet and their brother loves this book (it's also free on google). That will help you learn about the theory behind the software.
I also think you should talk to a professor who does computational work to let you toy around with it. I've had two advisors now in comp chem, and I get the feeling if a student came to either of them and said they wanted to play around with the software and see what comp chem is like, both of those professors would probably have been happy to set them up with an account to a supercomputer and show them a few tricks to setting up jobs, running simulations/calculations, viewing data, etc.
I would advise you to get really comfortable with C++. There are many reasons for this, and game development is one of them. Go to your local library, a book store, or a website that sells books and just check for books about C++. There's many parts to game development, aside from programming. There's probably a bunch of books that focus on game development in it's entirety. Some game libraries for C++ include APIs like DirectX and OpenGL (windows-only, cross platform respectively).
I always see this book recommended: Accelerated C++ What I'm saying should be taken with a grain of salt, as it's just one person's opinion and I am no expert.
Umm, I think Python is a good language to start with. It's forgiving and low on boilerplate code. I haven't read it but Learn Python the Hard Way by Zed Shaw is supposed to be decent (and it's free online). I didn't like Learning Python published by O'Reilly. I'd just read reviews on Amazon if Learn Python the Hard Way isn't working for you. Whichever you end up with, I recommend typing all examples from the book into the computer by hand. Something about doing this really helps make things stick in your head. You'll also make the occasional typo and have to debug your program which is something we programmers spend more time doing than any of us care to admit.
I think it is important to try to think of something you want to make and have it in mind while you are learning the language. It can be any software but I recommend a video game. They are really good for this because you can just think up a simple concept or implement your own version of an existing game. Having a goal makes it so you are constantly solving the problems you will encounter while trying to reach that goal which is the most important part of programming (more so than learning the syntax of the language). This is actually the highest rated Python book on Amazon and is all about gamedev with Python.
After you've learned Python to the point where you are comfortable (no need to master it), learn other languages to grow as a programmer. Once you've gotten a couple languages under your belt it's actually really easy to learn even more languages (unless it's a very odd language like Haskell, Lisp, or Brainfuck). The problem solving skills you've acquired often work in any language and you learn some new techniques as you learn new languages.
>After reading all the comments, I ve decided to pick up C# and learn it this summer. If and hopefully I will manage to do it by then, I ll start working in unity and focus on it for half a year or so. Then I ll study C++ and switch to Unrea(as both are more advanced as far as I ve understood)!
>
>Here are the following books I ll use to learn C#: "Yellow Book" by Rob Miles along with "Begin to code wtih C# " and also try The C# "Player's Guide"
>
>For Unity: their website, a lot of youtube tutorials
>
>And for C++: "Accelerated C++: Practical Programming by Example"
>
>
>
>If you guys have better suggestions I`m all ears.Thank you all for the help, really means a lot to me!
These are books I actually own and would recommend. Of course there are other great/better books out there, but I'm going to stick with what I've actually bought and read or "read".
I say "read" because several books are NOT meant to be read cover-to-cover. These typically have about 1/3 that you should read like normal, and then skim the rest and know what's in the rest so that you can quickly reference it. These books are no less important, and often even more important. I've marked these kind of books as #ref for "read for reference". Normal books that should be read cover-to-cover are marked #read
For learning your first language: This is really the hardest part and unfortunately I don't have any books here I can vouch for. I started with "C++ for Dummies" and am not including a link because it's bad. Your best bet is probably "Learning <language>" by Oreily. I also love the Oreily pocket books because you can carry them and skim while on the bus or the john, but you can just do the same with your smartphone. Pocket Python, Pocket Java, Pocket C++
Top Recommendations:
Accelerated C++ #read Made for people who already know another language and want to pickup C++. Also great for people who need a refresher on C++. I really like how it doesn't start with OOP but gets you familiar with the imperative parts of C++ before diving into OOP.
The Algorithm Design Manual #ref This is my new favorite book and the first I would send back in time to myself if I could. Each algorithm & data structure is given a mathematical breakdown, pseudocode, implementation in very readable C, a picture (very helpful), and an interesting war story of how it Saved The Day.
Cracking the Coding Interview #read I originally avoided this book like the plague because it represented everything I hate about coding interviews, but many interviewers pull questions straight from this book so this book can equal getting a job. Put that way, it's ROI is insane.
The Pragmatic Programmer #read Must-have for any profressional software engineer that covers best-practices for code and your growth. You can also find the raw tips list here
Head First Design Patterns #read Many prefer the "GoF/Gang of Four" Design Patterns which is more iconic, but Head First is a modern-version using Java to cover actual design patterns used day-to-day by programmers.
For Intermediates:
Effective Java or Effective C++ and Effective Modern C++ #read When you're ready to go deep into one language, these books will give you a huge boost to writing good Java and C++.
Design Patterns #ref You'll want to get this at some point, but early on it's too much for a beginner and many of the patterns are obsolete.
The Art of Computer Programming #ref The programming "bible" but like Design Patterns you should hold off on this iconic book until you've got your basics covered. It would make for a great purchase with your first paycheck or first promotion :)
EducacionIT es decente. Mas allá de lo que hagas. Lo mas importante es que practiques e intentes hacer cosas. Lo que lees no sirve si no lo usás.
Te recomiendo muchísimo que aprendas, en cuanto sepas usar mínima-mente las herramientas, como hacer unit tests y que es Test-Driven Development.
Este libro es excelente para entender TDD y está en java