Best software design & engeneering books according to redditors
We found 4,058 Reddit comments discussing the best software design & engeneering books. We ranked the 766 resulting products by number of redditors who mentioned them. Here are the top 20.
The exact four books I read are:
Learning Obj-C
Learning Java
iOS Programming: The Big Nerd Ranch Guide
Android Programming: The Big Nerd Ranch Guide
However, I would now recommend learning Swift instead of Obj-C. At the time when I was looking into iOS books, good books on Swift were few and far between.
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
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.
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).
Clean Code
Here below is my copy pasta of C#/Unity stuff which I post pretty often on /r/learnprogramming and /r/learncsharp . I only need to find a moment one day and add some computer science theory links.
Free C# ebook
• http://www.csharpcourse.com/ <- The download link is under 'here' at the end of the first paragraph.
Youtube tutorials:
• https://www.youtube.com/playlist?list=PLGLfVvz_LVvRX6xK1oi0reKci6ignjdSa <- apart from C# this dude has also A LOT OF other tutorials on many other languages.
• https://www.youtube.com/watch?v=pSiIHe2uZ2w <- has also pretty good Unity tutorials.
• https://scottlilly.com/build-a-cwpf-rpg/ <- learn WPF (desktop application with GUI) by making simple RPG game.
• https://www.youtube.com/user/IAmTimCorey <- This guy is also good, but I dislike his coding style and that he uses a lot of nugets instead of writing stuff himself.
Book reference guide:
• https://www.amazon.com/C-7-0-Nutshell-Definitive-Reference/dp/1491987650/ref=sr_1_1?ie=UTF8&amp;qid=1547990420&amp;sr=8-1&amp;keywords=C%23+in+a+nutshell <- But treat is as a language reference guide, not a programming learning guide.
Text-based tutorials
• https://www.tutorialspoint.com/csharp/index.htm <- C#
• https://www.tutorialspoint.com//wpf/index.htm <- WPF (GUI programming)
Udemy - wait for $10 sale which occurs at least once in a month:
• https://www.udemy.com/csharp-tutorial-for-beginners/ <- for C#, dude has also more advanced tutorials to choose from.
• https://www.udemy.com/user/bentristem/ <- for Unity
Do not move to Unity or WPF before you get good grasp on C# syntax and OOP concepts. Bear in mind that majority of Unity tutorials present abysmal C# coding style and practices. So I wouldn't recommend learning C# from such courses.
Coding style (read after getting good grasp of OOP concepts)
• https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship-ebook/dp/B001GSTOAM/ref=sr_1_1?keywords=clean+code&amp;qid=1562330510&amp;s=gateway&amp;sr=8-1 <- Clean Code, recommended for every newcomer at my work
• https://www.amazon.com/gp/product/B075LRM681?pf_rd_p=2d1ab404-3b11-4c97-b3db-48081e145e35&amp;pf_rd_r=22NFZ5GCWM7YMK2A5A2G <- Clean Architecture
Some book recommendations:
Others that are great and related but not as "necessary" as the above three:
Unrelated to "better code" but still great:
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.
Books
Frameworks
Tools
Communities
My best advice is to avoid "It's easy to write an app" tutorials. They put you in way over your head and when there's something wrong with the tutorial (or you mistype something) you flounder.
Instead focus on "the basics" of programming. For loops. If statements. Basic control flow. Variable assignment.
Next focus on understanding Object Oriented Programming. It'll take a while to wrap your head around it, but it's the foundation of everything Apple provides you to write apps.
For these two steps I used this book but you might want to find something based on Swift, since that's the new hip thing.
Then you start learning Apple's frameworks. Do a bunch of tutorials. Write your own app. When you realize it sucks and you'd be embarrassed to share it with anyone dump it and start over. Write lots of apps that do stupid little things. Make them bigger. After a few times you may have something cool, but more importantly you'll have learned a bunch of stuff you can't learn by doing tutorials.
Try to remember when it's late at night and you're crying with your head down on the desk because you can't get it to work that programming is fun. (That's sarcasm, but you need to know that even expert programmers went through it too. If you keep plugging you'll get better.)
Sure!
&#x200B;
I think two classic books to start with is
&#x200B;
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).
&#x200B;
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
&#x200B;
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):
&#x200B;
There's a lot more where that came from, so let me know if you get through that and are craving more material.
&#x200B;
Here are a couple videos as well:
&#x200B;
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/
&#x200B;
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.
&#x200B;
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.
Edit: these are not affiliate links :)
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
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
For a practical top-down approach to pentesting, this book was monumental for me learning the process of pentesting. I have mentioned the OSCP, and while that is an advanced course, it has benefited me greatly to excel at what I do. It's difficult to give you a starting point now, since when I started the security field was very different. I would say here and netsec are solid communities to get help on something specific, but you definitely want to have working knowledge before asking about it.
Clean Code is widely considered (at least in my circles) as a "must read" position for a pragmatic coder.
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/
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!
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
&#x200B;
&#x200B;
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 :).
Get Effective Java by Josh Bloch.
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.
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
&#x200B;
Software Industry
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.
Also I highly recommend THP2 (pentesting focused) (you can skip THP, its contents are all included and better organized in THP2) and THP3 (red teaming focused). Peter also hosts awesome trainings which I've leveraged into internships and jobs. more info at https://securepla.net/training
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.
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:
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.
For all the posts that will eventually come, PHP is a viable language to learn. I'm not saying it's the best language, nor a language that I would point to as an example of "this is how all programming should be done", but there's one big thing PHP has going for it:
For The Web, It Gets Shit Done
So, really, stop with the hate.
As for learning PHP, don't start with a framework. Learn core PHP first and then pick a framework. You'll have a better understanding about what is going on.
Join a local user group. Even if you can't make it to meetings, most of them have newsgroups that you can post questions to and get local advice. Check out http://www.zend.com/en/community/local-php-groups to see if there is one near you.
If you're not on Twitter, get on there to follow big names in the community. @calevans, @lornajane, @weierophinney, and @grmpyprogrammer are a few to follow.
Resources for help that aid in learning PHP:
[Edit]
And before I get downvoted to hell for daring to support PHP, keep in mind that I'm not saying the OP should only learn PHP. Ruby, Python, and .NET all have great things going for them, and PHP should just be one tool in a programmer's toolbox if they are programming for the web.
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.
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&amp;qid=1456913184&amp;sr=8-1&amp;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.
Here is a "curriculum" of sorts I would suggest, as it's fairly close to how I learned:
Generally you'll probably want to look into IA-32 and the best starting point is the Intel Architecture manual itself, the .pdf can be found here (pdf link).
Because of the depth of that .pdf I would suggest using it mainly as a reference guide while studying "Computer Systems: A Programmers Perspective" and "Secrets of Reverse Engineering".
Of course if you just want to do "pentesting/vuln assessment" in which you rely more on toolsets (for example, Nmap>Nessus>Metasploit) structured around a methodology/framework than you may want to look into one of the PACKT books on Kali or backtrack, get familiar with the tools you will use such as Nmap and Wireshark, and learn basic Networking (a simple CompTIA Networking+ book will be a good enough start). I personally did not go this route nor would I recommend it as it generally shys away from the foundations and seems to me to be settling for becoming comfortable with tools that abstract you from the real "meat" of exploitation and all the things that make NetSec great, fun and challenging in the first place. But everyone is different and it's really more of a personal choice. (By the way, I'm not suggesting this is "lame" or anything, it was just not for me.)
*edited a name out
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
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!
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.
I'm taking it right now. The books I read through or started before the OSCP in no particular order:
Honestly, if I could go back and prepare for the course again, I would have just learned the basics of python and then really focused on bash scripting. You're going to learn a metric fuck ton in the course. Remember, you're not paying just for the cert - you're paying for a course to get you to the cert.
By Essential Java, I take it you mean Effective Java, right?
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
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.
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
Go read Clean Code: A Handbook of Agile Software Craftsmanship and write beautiful code yourself.
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 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.
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
If you don't have any prior knowledge with programming, I'd first recommend learning Python. If you do have programming knowledge, then jump straight into ObjC. I read these 3 books and my Objective-C knowledge grew so much. I highly recommend reading these books.
Book One
Book Two
Book Three
I'd recommend reading these books in the order I listed them.
After you have read those books, you'll want to get friendly with theos. Theos is what you will use to make your tweaks. Learn how to install/use it here: http://iphonedevwiki.net/index.php/Theos/Getting_Started.
Now, you can look at open source tweaks. There is a great place to see a lot of them: http://iphonedevwiki.net/index.php/Open_Source_Projects.
Once you are comfortable, get started writing tweaks!
Always feel free to PM me if you need any help or have a question. :)
The first thing that comes to mind is understanding scope. In particular, if you come from a C-esque language, this might be one of your biggest hangups. Understanding how the scope works before you write your code will inevitably lead to a better-written product.
(tl;dr for the rest of this: know the fundamentals)
The route I came up, I started as an OOP developer and thought JS was a toy language for much of my career. It wasn't until I took the time to understand the language that I came into my own as a JS dev, and it is currently my favorite language to develop for. If you're the book-reading sort, I would suggest the following resources in sequence:
If you follow this link and look at the Frequently Bought Together section, you'll see that these three form a common trifecta. What you can expect:
(edit: added link to Amazon page for the first of the three books, fixed formatting)
It really depends on what niche you're looking on covering. It's difficult, I feel, to brush up on "infosec" to any level of practical proficiency without focusing on a few subsets. Based on your interests, I would recommend the following books.
General Hacking:
Hacking Exposed
The Art of Exploitation
The Art of Deception
Intrusion Detection / Incident Response:
Network Flow Analysis
The Tao of Network Security Monitoring
Practical Intrusion Analysis
Real Digital Forensics
Reverse Engineering:
Reversing: Secrets of Reverse Engineering
The Ida Pro Book
Malware Analyst Cookbook
Malware Forensics
Digital Forensics:
File System Forensic Analysis
Windows Forensic Analysis
Real Digital Forensics
The Rootkit Arsenal
Hope this helps. If you're a University student, you might have access to Safari Books Online, which has access to almost all of these books, and more. You can also purchase a personal subscription for like $23 a month. It's a bit pricey, but they have an awesome library of technical books.
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 recommend picking up a copy of either Programming Principles and Practice Using C++ or C++ Primer.
&#x200B;
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.
> 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 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.
Hey man! I work as Security Analyst - about a year away from graduating with my Bachelors.
I suggest you pick up the CompTIA Security+ Certification, as well as start learning the basics of Networks and how they function. Learn ports and protocols, as well as how IDS/IPS/Firewalls function. This will get you an entry level role as a Jr Analyst. I suggest you use [http://www.professormesser.com/security-plus/sy0-401/sy0-401-course-index/](Professor Messers Security+ Videos) This will teach you the basics of security work, networking concepts, threats, etc.
At the same time start listening to podcasts like Paul's Security Weekly, Down the Security Rabbit Hole, etc. As well as start reading blogs on hacking to get a feel for whats done.
Get a home lab and learn a few tools like Wireshark and Nmap for basic Security Analyst work - to learn how packets work, how they are structured, and how to scan pc's for ports and services. At the same time, focus on learning about threats and vulnerabilities (which are covered in security+).
If you want to get into PenTesting then you need a wide range of knowledge. Pick up and learn a few languages (master the basics and understand what the code does and how to read/interpret it). You need to know: PHP, HTML, SQL, Python (or Ruby), and a basic language like C, or Java.
If you want to dig deeper into PenTesting then start reading: https://www.offensive-security.com/metasploit-unleashed/
Good way to get into the Kali Distro and learn how to run Metasploit against vulnerable VM's.
Take a look at https://www.vulnhub.com/resources/ for books, and vulnerable VM's to practice on.
https://www.cybrary.it/ is also a good place with tons of videos on Ethical Hacking, Post Exploitation, Python for Security, Metasploit, etc.
Pick up some books such as
The Hacker Playbook 2: Practical Guide To Penetration Testing
Hacking: The Art of Exploitation
Black Hat Python: Python Programming for Hackers and Pentesters
Rtfm: Red Team Field Manual
The Hackers Playbook and The Art of Exploitation are great resources to get you started and take you step by step on pen testing that will allow you to alter explore the endless possibilities.
Also a good list of resources that you can learn more about security:
Getting Started in Information Security
Pentester Labs
Awesome InfoSec
Awesome Pentest
Overall experience and certification are what will get you into the door faster. Most employers will look for experience, but if they see you have motivation to learn and the drive to do so, then they might take you. Certifications also are big in the infosec field, as they get you past HR. And having a home lab and doing side projects in security also reflects well.
Hacker playbook 2 is always my recommendation for reference and a good guide to PTES.
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&amp;ie=UTF8&amp;qid=1382580434&amp;sr=1-2&amp;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.
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.
Clean Code
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.
Checkout the book PHP Objects, Patterns and Practice by Matt Zandstra, it helped me dive right into OOP after years of procedural programming.
CLR via C# for a better understanding of the runtime you're working with.
C# in Depth for a deep dive into the language and it's features and their details of implementation.
I'd consider those two to be the primary intermediate texts.
On this topic I’d like to recommend this book:
https://www.amazon.com/Working-Effectively-Legacy-Michael-Feathers/dp/0131177052
/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.
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.
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.
There's a reason why there is a Javascript book (1096 pages) and another called Javascript: The Good Parts (176 pages).
I think the bible could use a similar treatment.
Chapter 3 - Windows fundamentals; Secrets of Reverse engineering by Eldad Eilam should be an easy high level overview of the subject. The rest of the book is a great resource too.
For reverse engineering:
For malware analysis and malware techniques
For programming
This should be enough for you to get started.
Check out this online book, it covers a wide array of PHP topics, but there are some solid chapters on objects including the building of a basic OOP website.
The book, PHP Objects, Patterns, and Practice is an incredible resource of PHP OOP concepts and application design. It starts off with a few chapters on the basics of OO PHP coding, giving you the rundown of syntax and inner-workings. From there it covers popular OOP design patterns (MVC, Adapter, Component, etc) and then lives up to its name by showing the patterns in practice.
After you've picked up the basics of OOP, check out a PHP web framework. I would recommend CodeIgniter for its amazing documentation, not to mention this wonderful set of video tutorials CodeIgniter from Scractch featured on Nettuts.
Once you get a working knowledge of a framework and have built some basic applications and websites, take the time to study the code behind the framework. Find out where the entry point is and trace its execution, checking out the source for each and ever object that is instantiated. Not only will you pick up on some sweet OOP concepts, but you'll gain a great understanding of how a typical OO PHP application is structured.
Good luck and have fun!
Keep your programs DRY! (Don't repeat yourself) In procedural, you would take those large blocks of code and faction them up into functions. With OOP, look even more abstractly and take several large blocks of related code and put them into classes, which are, at a very basic level, a collection of related functions and properties.
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
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?
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.
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.
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.
Ah, the context of the Uncle Bob rant from a few weeks ago. I don't see how any of the author's particular complaints have anything to do with TDD:
> You therefore are more reluctant to make large-scale changes
> that will lead to the failure of lots of tests. Psychologically, you
> become conservative to avoid breaking lots of tests.
This is a bad thing? If you think a whole lot of tests might break if you make large changes, clearly there are massive side-effects to the change you propose, and then wouldn't a conservative approach to making the changes be the right thing to do?
Personally, I like fixing broken tests when I make large changes. It gives me greater confidence that I won't introduce regressions and allows me to understand the impact of what I am doing and gives me insights to the design of the system, particularly when it comes to the level of coupling.
But, this is the consequence of having a test suite, and doesn't say anything about whether that test suite was created through TDD.
> Sometimes, the best design is one that’s hard to test so you are
> more reluctant to take this approach because you know that
> you’ll spend a lot more time designing and writing tests
The author didn't give an example of this, but I am assuming he probably means GUIs. Well, not everything needs to be tested, and especially with TDD. The key is to separate code that needs to be tested from code that doesn't (or tested in a different way).
When it comes to GUIs, I usually write a "shell" without tests (because really, besides interaction, what are you testing?) and delegate functionality to interior objects which I definitely implement test first.
Another example I can think of is heavily algorithmic code. Like, back in the day, I worked on seismic processing software. Well of course, you don't develop those kinds of algorithms test first (or, maybe in a very different way - the geoscientists involved wrote papers which discussed the math involved before writing any code). But again, like GUI programming, the seismic processing algorithms were isolated from the rest of the system, which was written test first.
TDD works well for some types of code and not others. The requirement of using judgement to decide the development processes for specific cases has nothing to do with the effectiveness of TDD as a general practice.
> The most serious problem for me is that it encourages a focus
> on sorting out detail to pass tests rather than looking at the
> program as a whole.
No it doesn't. Test-first just means you write tests before you write the code. That doesn't mean you can't look at the program as a whole first before that. The first half of Uncle Bob's book Agile Patterns, Principles and Practices is devoted to UML. Yes, you heard that right.
Check out this chapter from that book, Heuristics and Coffee. Before diving into the code, Uncle Bob spends a good chunk of time going through the use cases and coming up with a first pass at a high level structure for the system, in UML.
TDD is one part of "Agile" software development, where the rubber hits the road. But before you start driving, you should have a basic idea of where you are going, which is design. The "epicycles" of TDD then serve to validate that you are on the right course, from minor turn-by-turn directions to occasionally stepping back and making sure you are still on course.
The idea is to come up with as much UML as necessary to get a basic idea of the overall design, and then use TDD to execute and validate that design, incrementally.
The author is taking TDD out of context and missing the bigger picture.
> But the reality is that it’s often hard to specify what ‘correct
> data’ means and sometimes you have to simply process the data
> you’ve got rather than the data that you’d like to have.
What does this have to do with TDD? Again, TDD is a part of a larger process, which involves the business. Software that does "real work" doesn't work in a vacuum. Programmers have to deal with the business to understand the data to the best of their ability, and even still, you'll still make mistakes.
At least the tests document an executable understanding of the data, and test failures can actually give valuable insights on changing assumptions of the data.
/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.
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.
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.
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.
Hey, I'm flattered you care what I think!
I learned basic Objective-C on my own in high school (read this one during boring classes), and then went on to do a Bachelor in Computer Science at uni. Learning some basic programming really helps, because at least at my school it was very much fundamentals for the full first year, and if you understand them well enough it'll be a breeze.
That being said (and take this with a major grain of salt, as it's just me) I wasn't that big a fan of school. I got into and taught myself iOS development as my school, like most, was mostly based around Computer Science theory rather than practical applications and programming. I did learn some valuable things about algorithms and whatnot, but it's nothing that I couldn't have taught myself and everything that I've found to be "marketable" (things that have helped me get jobs) have been self-taught.
But university's awesome for a whole wealth of reasons (met awesome people), and you may adore it, I'd just be very careful not to learn a wealth of knowledge but have little experience applying it to anything concrete. Employers appreciate the latter far more (my GPA was rather meh, and I got some really cool jobs).
I do most of my work alone, but a lot of smart people have helped me along the way. :) It's just how I personally like to work at the moment. If you have any more questions I'm happy to answer. r/cscareerquestions as mentioned is a great resource too!
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.
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/
The Big Nerd Ranch guide to Objective-C Programming is what you need.
It covers the basics of C programming (variables, loops, etc.) before quickly moving on to Mac and iOS specific tutorials. Small book, short chapters, and easy to read.
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.
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.
It is an academic paper and written as such. For a more practical approach to the topic, try some of these:
Programming Pearls
Performance Bugs
Performance Engineering of Software System
https://www.amazon.com/Test-Driven-Development-Kent-Beck/dp/0321146530
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):
> 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:
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!
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!
Clean Code
vs
Code Complete
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
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
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
> What did you use to learn how to write the code?
I read this book to get started: Programming in Objective-C by Stephen G. Kochan
I highly recommend it for starters, since it provides lots of easy explanations, exercises and guides.
And since you need a 2D physics framework to program a game, I decided to use Apple's native framework called SpriteKit. I learned SpriteKit's basics with YouTube tutorials and this free online course.
I also recommend everyone to google some open source games/apps to learn some programming methods & techniques.
> What tool was the app built in? XCode? Unity?
Xcode.
Best book to start with C#/.net is CLR via C#. And to keep yourself up to date you can read MS articles about new features in new versions of C# / .net.
A lot of these people have university degrees or better knowledge about ASM and dissecting than your university professors. Do you really believe people without qualification could beat a software solution of a multi-million dollar company that's sole propose is to protect software (VMProtect and Denuvo), that employs security researches and experts with 10+ years experience in the field and did years of development on said DRM? You sound like you don't have the slightest idea about the amount of brain power that goes into reversing something that doesn't want to be reversed. Maybe educate yourself before drawing conclusions.
Depending on the sort of hacking you want to do, your programming skills will likely complement your learning experience very well.
Depending on what sort of programming you've been doing and what your target is, it could also be totally irrelevant.
If you're looking to find exploits in software (i.e inside of a server) you'll need to understand how to reverse engineer it and search for exploits - getting a hang of IDA Pro and OllyDbg will be key to this. If you're looking for software exploits, already understanding languages like C and C++ will be highly benificial. Understanding your target's platform will also be crucial.
If you want to get into exploiting websites etc your C programming probably won't be too helpful - since most scripts are most easily hacked up in python or php. If you have any experience in programming server-side logic in php and interfacing with databases then that would be applicable to this field.
As I am more into native software reverse engineering and not hacking webservers I can really only point you down the path of reverse engineering software. A very good book I found for this was http://www.amazon.ca/Reversing-Secrets-Engineering-Eldad-Eilam/dp/0764574817
This book will guide you through the process of offline and online analysis with ollydbg and IDA. Further it will introduce you to the internal workings on the windows platform (which is crucial if you're looking to reverse engineer targets on the windows platform.)
There are some good books on IDA Pro as well.
You can dive right into Objective C, I was only vaguely familiar with C and I've published a few apps without any problems. However, if you're intent on learning C pick up 'The C Programming Language' (K&R), not only the best C programming book, but one of the best programming books ever written.
Objective C books, I recommend one of the two or both books,
'Programming in Objective C 3rd edition' or
'Objective C: The Big Nerd Ranch Guide'
Both of these books are excellent resources for learning and I keep them close by whenever I have a question.
In terms of learning iOS development. I recommend going into iTunes U and downloading the latest Stanford University iPhone development course. I believe Winter 10 is the newest, follow along those classes and the class website, treat it like a real class, do the homework and all the assignments. There is no text book for the class, but this other book by Big Nerd Ranch, 'iOS Programming: The Big Nerd Ranch Way' is totally awesome.
After these classes and books you should have a great foundation for iOS development. Once you feel comfortable with everything and have an app or two under your belt, download Madison Technical College's Advanced iPhone Development course videos from iTunes U and Apple's own WWDC Session Videos.
Each MTC video is about 3 hours, watch them in chunks. The professor, Brad Larson is one of the best iPhone developers out there and in my opinion is one the best contributors to the community, (see his posts on stack overflow).
Lastly, check out www.raywenderlich.com. My personal favorite iPhone development website. It's updated every Monday, Wednesday, Friday with great technical tutorials that are funny and educational.
Best of luck to you and welcome to iOS development :-D.
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
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.
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
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
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.
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.
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.
> Clr via c#
amazon link for the lazy
Yea, I actually recommended one in the post above. Here's a direct link though
I'm recommending this only because it's the one book on the topic that I've read and it was really good. There's others too, like this one, but I haven't read them so I can't comment.
Any book about reverse engineering can only teach you the most basic things. But it teaches you enough that once you're on your own, you aren't lost. If you want to develop the skills further, just start disassembling OS functions and figuring out how they work.
Another book that's tangentially related is this one. It isn't about reverse engineering specifically, but rather about debugging (usually without source code), which is obviously a critical skill.
Hey /u/Xerack! I'm the original author of the post linked here.
Appreciate the feedback! If you think I could clarify anything better, please let me know.
As far as resources for Reverse Engineering, I can provide you with a baseline that I would recommend starting with.
x86 Assembly:
If you don't know assembly language at all, this list of videos was where I picked up a decent amount of x86 assembly language.
A few good books would be:
Hands On:
Courses:
Tons of courses on youtube. I learn well from visual, so I recommend these youtube videos:
Beyond that, Google will always be your friend, and /r/reverseengineering. I also have a bunch of material for Malware RE, but that's a bit different than Software RE, though it is relatable.
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).
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
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
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.
The best way I know how is by solving problems yourself and looking at good solutions of others.
You could consider going back to "fundamentals".
Most programming courses, IMO, don't have nearly as many exercises I think they should have. Some books are particularly good on their exercises list, for example K&R2, SICP, and TC++PL. Deitel's has long exercises lists, but I don't think they're particularly challenging.
There are some algorithms/DS books which focus on the sort of problem solving which is about finding solutions to problems in context (not always a "realistic" one). Like the "Programming Challenges" book. In a book like that, a problem won't be presented in a simple abstract form, like "write an algorithm to sort numbers". It'll be inside some context, like a word problem. And to solve that "word problem", you'll have to find out which traditional CS problems you could solve/combine to get the solution. Sometimes, you'll just have to roll something on your own. Like a new algorithm for the problem at hand. In general, this helps you work out your reduction skills, for once. It also helps you spotting applications to those classical CS problems, like graph traversal, finding shortest plath, and so forth.
Most algorithms/DS books though will present problems in a pretty abstract context. Like Cormen's.
I think, however, people don't give enough credit to the potential of doing the exercises on the books I've mentioned in the beginning.
Some books I think are worth reading which also have good exercises:
I imagine the other Stroustrupp programming book also has good exercises, but I've never read it. Brian Kernighan is not only the author of K&R2, but of many other books. You could look at his stuff.
Depending on what you mean by good code, though, you could look at other books.
There are also the math books. I'd not discard those. And also, there are other programming books as well. Some I've never read, but want to, like Programming Pearls:
Not only those, but, anyway... The point is that you can look at those books to find examples of good code, good exercises, challenges and so forth.
Here are some books I've mentioned previously:
By the way, there are websites with programming challenges for you to look at too. Like https://projecteuler.net/ and others. Just start looking this up and you'll find plenty. They all tend to start dumb easy and move up the difficulty to pretty damn difficult stuff from what I've heard.
Edit: SICP is available for free (http://mitpress.mit.edu/sicp/) together with videos from the course taught at MIT in 85 (http://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-001-structure-and-interpretation-of-computer-programs-spring-2005/video-lectures/).
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
Read 'Continuous Delivery', 'The DevOps handbook', and perhaps 'Accelerate'.
I'm currently using Objective-C Programming: The Big Nerd Ranch Guide
So far I haven't learned much that I didn't already know from Java or Python, but if you don't have any programming experience I'd say this is a great start
The Big Nerd Ranch book on Objective-C doesn't assume you have any programming experience and I've found it helpful for someone that's not very familiar with compiled languages. Also, it was published very recently, so it stands a chance at being most up to date.
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:
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
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.
Just FYI, the 3rd edition came out June 2010
http://www.amazon.com/Objects-Patterns-Practice-Experts-Source/dp/143022925X/ref=sr_1_3?ie=UTF8&amp;s=books&amp;qid=1302134786&amp;sr=1-3
PHP the right way is a very good site, but for books one of my favorite in php is http://www.amazon.com/dp/143022925X/ PHP Objects, Patterns and Practice. I never used media wiki but joomlas code base a few years ago was a joke (hope it has gotten better!).
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).
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.
CLR via C#
This is the only book you need as a beginner to C# who already knows other languages.
What are you waiting for? Go get it! Read it! And impress the shit out of your employer.
I actually already have a copy of Hacking: The Art of Exploitation. My personal library consists of around 45 books on a range of computing topics from PHP, MySQL, C++, Windows Internals, CCNA, MCSE/MCSA, Unix, Rootkits, AI, Data Structures and the list goes on.
Other relevant titles include Gray Hat Python, Reversing: Secrets of Reverse Engineering and Rootkits: Subverting the Windows Kernel.
I was going to buy the following: Assembly Language Step-by-step, SQL Injection Attacks and Defense and Metasploit: The Penetration Tester's Guide.
I agree that where one starts really depends on what they want to end up doing. "Hacking" is such a general term and SQL-Injections is completely different from finding 0-days. If I'm honest I'm not sure where to start but I'm open to suggestions.
&#x200B;
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.
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.
Refactoring is a classic, and surprisingly readable.
http://www.oreillynet.com/ruby/blog/2006/03/transformation.html
Actually, I've seen quite a few loop invariants in shipping production code. But probably 95% of the times they're used, the programmer might not even think to call it a loop invariant.
Specifically, a lot of codebases use conditional assertions to test for bad conditions (usually debug-only). If you place a conditional assertion in a loop, you're expressing a loop invariant. I personally have used them to find a number of bugs in shipping production code.
Read Programming Pearl's - it's very short classic, and he uses loop-invariants via assertions.
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.
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 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
> 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.
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
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.
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.
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.
Effective Java
Head First Design Patterns
http://www.theserverside.com/
http://stackoverflow.com/questions/tagged/java
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
>What would be the best way to prepare for these types of interviews? What sources/books did you use to study data structures and algorithms?
Get a friend and have them run you through practice interviews. Lots of them. Get used to writing code on a whiteboard, because it's different from writing code in an IDE.
For algorithm practice, I bought Introduction to Algorithms and Programming Pearls. I also did a lot of research online to find out the kind of interview questions to expect. (Ignore the brainteaser questions; Microsoft doesn't do them any more.)
For the most part, just hit the books, study hard, and write lots of code on a whiteboard. This article by Steve Yegge really nails it, I think.
>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
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.
I would say either JavaScript: The Definitive Guide or Speaking and Exploring JavaScript
I've recently been working on my JS skills and heres a few resources I've found super useful:
Books:
Javascript Patterns
Javascript: The Good Parts
Javascript: The Definitive Guide (While an exhausive resource on the topic, this one is a bit verbose)
Web:
Mozilla's Javascript Guide (One of the best free online javascript guides/references.
How to Node (Tutorials on server-side Node.js)
Daily JS (Interesting JS related news)
Echo JS (Similar to above but updates less frequently)
Hacker News (This is more general tech news but there is a ton of useful web stuff, especially as node.js is currently a hot topic. Reddit actually spawned from HN)
Online Videos (free)
Douglas Crockford's Javascript Lectures (I would recommend these to anyone getting into javascript)
I learnt ( in fact I am still learning ) JS from YDKJS ( all books read almost 80% , you can view them legally here ) , EJ (read almost 60% , you can download it legally from here , the site of the book is here ) and MDN , with a background of : I know what if and for does and i also know what a function is . My advice is to jump from one resource to another if you feel you are stuck . Also I did not read them linearly . Another book that is useful although a bit outdated is DOM enlightment (read almost 20% of it) . I do believe that professional JS , and javascript.info are also worth to take a look .
Other resources for JS are a meh from me .
I have no clue about the third book in the video .
edit : js the definitive guide is also worth looking although a bit outdated .
Learn what's happening at the metal.
Edit: I'll be a little more helpful and say read this book: https://www.amazon.com/CLR-via-4th-Developer-Reference/dp/0735667454 (not an affiliate link)
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':
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.
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.
I'm currently studying from this book. Super easy to understand, and you'll get some decent projects out of it.
Alright man I was sort of in the same boat.
You don't have to rely on your Airforce job to be your only source of NetSec training. https://hireourheroes.org/veterans-training/
If NetSec is your passion you should start reading up on Blue team / Red Team type procedures. Get familiar with Firewalls and Cisco equipment. Work on getting maybe a CCNA Sec, work your way to a CISSP. Learn networking itself inside and out, to form a base for the security concepts. Practice Network Forensics, learn about write-blockers, legal procedures to work NetSec, that kinda stuff. If you find the time, learn Python.
https://www.amazon.com/Hacker-Playbook-Practical-Penetration-Testing/dp/1512214566/ref=sr_1_sc_1?ie=UTF8&amp;qid=1474252248&amp;sr=8-1-spell&amp;keywords=the+hacker+paybook+2
If you have Linux experience, a well recognized PenTest OS is Kali Linux. You can use it to practice on a home network, or build your own virtual environment.
I'm finishing my Bachelors in Cyber Security here in May and testing for my CISSP, if you want any more info on programs/certs stuff like that feel free to shoot a PM.
What I learned from reading Clean Code [1] is that developers spend far more time trying to read/understand code then they do actually writing it, they gave an empirical ratio of 10:1 for the time spent reading vs writing code. So I think it's worth it in the long run to make your code cleaner/understandable for other devs.
I highly recommend the book, they even have an entire chapter dedicated to meaningful names, so I think it's important to refactor variable names as well.
[1] Page 13 in the "We Are Authors" section (you can actually see it in the Amazon preview if you want)
Is it this?
https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship-ebook/dp/B001GSTOAM
&#x200B;
Code: The Hidden Language of Computer Hardware and Software
Clean Code: A Handbook of Agile Software Craftsmanship
Code Complete: A Practical Handbook of Software Construction
Algorithms
Types and Programming Languages
[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.
Here a some top notch books you'll need.
You also need a Mac to develop apps for iOS and OS X.
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?
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).
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.
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.
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.
In the real Command Pattern, commands do have an
executemethod.This excellent book by Uncle Bob devotes a great deal of time to that pattern if you'd like to learn more about it:
https://www.amazon.com/Agile-Principles-Patterns-Practices-C/dp/0131857258
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 :
[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
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.
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.
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:
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.
Here are some:
http://www.amazon.com/Test-Driven-Development-Addison-Wesley-Signature/dp/0321146530
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.
Swift:
Objective-C
>I liked the book with a scooter on the front...
Cocoa Programming for Mac OS X
I also recommend that book, along with Programming in Objective-C which I feel gives a more in-depth overview of the underlying Objective-C base of Cocoa.
I found Lynda.com to be extremely dry and slow. To me it was the equivalent of those old school mandated educational movies you would watch in classrooms back in the 90s on your faux-wood tv. Take this opinion with a grain of salt though as it has been almost two years since I have looked at anything on Lynda, I hear it may be better today.
If you are looking for web development in particular I would suggest the following:
In addition, StackOverflow; A general programming Q&A website, has an answer to just about any programming issue you may be running into. If the answer is not already there, then chances are you will have one within 24hours.
I began my pursuit into web development about 2 years ago. In that time I have gone through the resources listed above as well as the following books which have helped immensely:
Some personal career history if you're interested:
In the last two years I have gone from making 18k a year as a Technical Support Representative to 80k a year as a Front-End Engineer building JavaScript applications at a large FDIC Bank. It was only in the last two years that I really dug into Web Development (and programming for that matter) and I really can't see myself ever doing anything else for a living. The job requires an immense amount of learning (which I love) and will keep your mind sharp. I really do get a kick out of problem solving all day. Programming will require a major adjustment to the way you think. I can say that the way I work through problems now is completely different to the way I did before. I feel as if critical thinking has eluded me until the last two years and it has been a major life changing event. By far the biggest contributing factor to my growth has been the team I work with. You have to do your best to find a team that is willing to work with you as a junior so you can siphon that knowledge. Even if that means taking a low paying job, however; know your worth so that you can ask for the right amount of money once you have gained the necessary skills. As a personal rule of thumb, I will not stay at a company where I am the most knowledgable member of the team. This inhibits growth as a developer and will prevent me from realizing my true potential.
Feel free to hit me up if you have any questions.
I can definitely relate, this sounds just like me last year! I've done things the hard way and it took me 5x longer. I also prefer screencasts to books. I always need to create a project to solidify those fresh skills, otherwise they'll be gone in a month. Also tutorials for things like Backbone assume you know how to use jQuery, Underscore, and things like REST, and JSON responses... this can quickly get confusing if your not familiar with all of these. My largest regret is not building enough practice apps in the last year. I really should have applied more by doing, instead of staying in the theoretical world.
Here are some insights that i've made and the courses/tuts/projects that helped me the most:
Learn the language first:
Set up a comfy environment
Take some time to start optimizing your development environment, the Paul Irish explains it very well below, but some of the topics are a bit too advanced for now (modules, build tools, etc...).
Learn the native DOM and it's API
Learn jQuery
Read "The Good Parts"
Though very cliche at this point, read through this classic. If you don't really understand it all 100%, make sure you hang on to it though as it gets better with age. Try and follow it as close as possible, then later feel free to break the rules. By then you'll know why you can break them.
Learn Underscore
This is a great library that gives you a lot of cross browser ES5 features and features that should be in JS. Not a lot of tuts on this one, reading the docs and source helps a ton here.
Learn Backbone
There are lots of these libraries but Backbone is the most popular and easiest to learn. Keep in mind this is a library, not an entire framework like ember. This means in a larger app you will essentially use Backbone to help build you own SPA framework for your app.
http://cheeaun.com/blog/2012/03/how-i-built-hacker-news-mobile-web-app
http://cheeaun.com/blog/2012/03/how-i-built-hacker-news-mobile-web-app_26
Learn Node
General Front-End, Programming
Read a comprehensive JS book
I really like Nicholas Zakas's book over the definitive guide. I find that he is able to tell more of a story and makes it easier for me to absorb.
Testing
Make sure you're comfortable with everything before moving onto testing... this includes frameworks etc.. Learning testing will only slow down the learning process if you're not comfortable with the rest. Mocha is the newer test runner and is better with async. However, Jasmine is very popular and time tested. The "Lets code javascript" below is an awesome course. Don't let the first sections turn you off, they may seem tedious at first (integration server, etc...) so feel to skip to dom/browser testing and then loop back when testing is more normal.
--
I just started sketching out a website to try and solve this problem. It has different paths to follow to fill in gaps of JS knowledge quickly (much like hackdesign.org)... unfortunately it's not finished yet! Watch LevelUpJS on Github in the future. I also have some more links on app architecture and things like modules but this list is getting a bit large!
Cheers and good luck!
I was reading CLR via C# the other day and something that struck me is how often the author talked about the advantages of being to use multiple languages that can talk with one another seamlessly due to them all running on the CLR. The author seemed disappointed that VB became C# with slightly different syntax while other languages on the platform weren't really getting much love.
With C# getting pattern matching in the next version, I do wonder how far and how large C# will become, ultimately, and if we'll see a more distinct push to have more varied usage of other CLR languages to solve particular problems.
A more appropriate title would be "Some things you'd like to know about the CLR".
CLR via C# is really all you want to know about the CLR.
Reversing: Reversing: Secrets of Reverse Engineering
Practical Reverse Engineering: x86, x64, ARM, Windows Kernel, Reversing Tools, and Obfuscation
Reverse engineering, technically. Blizz doesn't actually publish an official list of available Lua API (which I find odd, personally), but you can find them by looking at memory dumps on each update.
You can also do an /etrace and then see the exact events being fired and thus record anything new. Though, that is a bit inefficient. Blizz often announces UI/Macro changes HERE
If you want to do your own scans to see the latest API check this out here
Some basics on how to do this can be found HERE, though it might be a bit outdated, it is quite good on how to learn for yourself how to reverse engineer programs
Reverse engineer Microsoft patches.
edit: serious answer:
I do this kind of work for a living. I started out in 1995 when I was 13 years old learning from mudge's excellent article on how to write buffer overflows and I progressed from there.
If you're analyzing software for which you have access to source code, you can't beat The Art of Software Security Assessment: Identifying and Preventing Software Vulnerabilities.
Chris Wysopal's Art of Software Security Testing is also good.
If you're attacking software for which you have no source code, learn about fuzzing and reverse engineering. An excellent intro to reverse engineering is Reversing: Secrets of Reverse Engineering.
Those will get you started, but it helps to have people around you who are successfully discovering and exploiting software vulnerabilities. This is also the kind of field where you absolutely have to stay on top of the latest developments in software security. Things move at a mind-boggling pace. Read security blogs, talk to people in the industry, read books, etc...
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!
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.
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.
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
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.
> "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
I've go with PHP Objects Patterns & Prac. I haven't read the other 2, but this book is definitely worth investing in
Came here to say the same thing; you don't NEED Kali to pentest, it's really mostly used because it has a lot of tools already included. You can test from a Windows box if you really wanted to.
Kali won't magically make you a pentester, nor will it teach you how to be one as it's just a bundle of tools - there's no tutorials included with those tools. Read Hackers Playbook 2 and Penetration Testing: A Hands-On Introduction to Hacking and do some vulnerable VM's from places like Vulnhub
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.
Check out this question on StackOverflow.
I could also vouch for PHP Objects, Patterns, and Practice. When I was learning OOP, I found the book straightforward and quite easy to understand.
I haven't read it all yet, but I've gotten through a good amount of PHP Objects, Patterns, and Practice by Matt Zandstra. Just like you, prior to reading this I was a seasoned PHP programmer but developed very little OOP stuff. The book provides some good real-world examples and also gives the pros/cons of the techniques he's teaching.
This was a good book - https://www.amazon.com/Hacker-Playbook-Practical-Penetration-Testing/dp/1512214566
Clean Code. I will always recommend it to any developer.
&#x200B;
https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship-ebook/dp/B001GSTOAM
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’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
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/
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.
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.
I lose interest all the time reading programming books. I will circle back if something comes up that reminds me of a subject of that book. Each CS book has a ton of material and knowledge in it, so keep that bookshelf stocked and keep on circling back. Since you're interested in reading up on programming a few of my personal favorites for beginners include:
Pragmatic Programmer: https://pragprog.com/book/tpp/the-pragmatic-programmer
Eloquent JavaScript: http://eloquentjavascript.net/
Programming Perls: https://www.amazon.com/Programming-Pearls-2nd-Jon-Bentley/dp/0201657880
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.
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.
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:
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.
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'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/
> 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.
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.
>The result is that I will feel pressure to commit to a certain amount during a sprint that I know I cannot complete unless I am working over 40 hours a week. This pressure does come from management in the form of surprise or confusion if I try to commit to less than everyone else who is working overtime.
Teams should be working at a sustainable pace. Some overtime is OK but consistent overtime will generally cause more harm than good. The Clean Coder and The Complete Software Developer's Career Guide recommend giving 40 hours per week to your employer. Any hours on top of that should be hours done for your self-improvement.
Only sign up for work that you feel comfortable completing in a 40 hour work week. If you start to get behind on a task towards the end of the sprint, just let the task carry over. My first thought when I see a task not finished in the sprint it was pulled into is "this task must have been more work than we thought." My first thought is not "whoever worked on this task must have been a low performer." If that is the first thought then the team has bigger problems.
The only time I consider it necessary to do overtime is if there is a critical defect in production or we are very far behind on a release and in a situation in which releasing late would cause a lot of problems for our clients or consumers. For example, I sometimes have deadlines set by the government and if I am late on a release, our clients will have to pay fines.
So I recommend only doing more than 40 hours per week during the above scenarios and if your manager has a problem with that then probably consider job searching.
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.
Pick up Effective Java on Amazon. It's the next step beyond the basics that teaches some really solid, fundamentals.
Once you have that under your belt, just have an idea and execute it to the best of your ability.
Then execute the next idea.
Then the next.
Then the next.
....
There's no shortcuts, just code your ass off. Learn by doing. If you want to make an app that you can use on your phone, pick up a book to do android (I assume) development (or just go through the public Android docs).
If you want to be able to use your app anywhere, grab a book for web development -- Everything is moving to Native Web, so I think that's the move towards longevity..
Effective Java
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.
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
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.
Step 1: get a better learning resource.
Most online tutorial suck. They're fine for a quick intro or to learn more about one feature, but not for learning everything from scratch.
Buy a book.
Programming in Objective-C is pretty good and it's aimed at beginners.
If you don't want a physical book, get the Kindle edition and read it online.
Step 2: spend more time building.
For every minute you spend reading or watching, you should spend 10 minutes trying it out, doing stuff.
Programming is not about knowledge, it's a craft, like woodworking or pottery. You can't just watch masters build things for a month, then go home and build a dresser. You need to start small, build up your skills before you can actually build useful things.
So as you're reading the book: are you learning to write a loop? Stop, put down the tutorial or book, and type it in and run it. Get used to the syntax. Experiment with it - can you make it do something different?
CLR Via C# is a really good book to have handy.
I've never done any embedded software development, but as a web developer looking at you from the other side, this is what I see...
At the domain level, you'll be working with different technologies than you're used to. Embedded software developers do a lot more low-level interactions with inputs from sensors, so you'll see less of that. Web developers are generally dealing more with human interaction and data persistence and retrieval.
Another big thing to think about would be your OOP experience. Are you familiar with SOLID? Have you done any real-world development using OOP? Most of the web frameworks available today (from a server-side standpoint, at least...particularly ASP.NET) are rooted in OOP.
If you've got 10 years of experience developing, learning C# will be easy. I wouldn't focus as much on the language itself as I would learning the .NET standard libraries. You'll pick up the patterns as you go. I really liked the "Pro ASP.NET MVC" books, now available for MVC 5.
If you're looking specifically for books on C# and .NET development, I don't think there's any book better than CLR via C#. Don't let the title scare you away, it's a great book for learning the lower-level bits of the .NET platform, which are relevant everywhere from ASP.NET to WinForms.
If you aren't aware, there are huge changes coming to the .NET framework and ASP.NET, so you could choose to focus on ASP.NET 5 and get ahead of the game a bit, at the expense of availability of reference material.
Yes.
Hacking Exposed
Shellcoders Handbook
Reverse Engineering
Malware Analyst's Cookbook
Gray Hat Python
Gray Hat Hacking Second Edition
Writing Security Tools & Exploits
Sockets, Shellcode, Porting and Coding: Reverese Engineering Exploits and Tool Coding for Security Professionals
Professional Penetration Testing
These are definitely some books you could start with. Once you've gone through those, you'll know more then a lot of them out there :)
There's these reddit threads on r/netsec:
http://www.reddit.com/r/netsec/comments/d3hua/how_to_get_started_in_netsec/
http://www.reddit.com/r/netsec/comments/ekyjw/interested_in_learning_about_network_security/
http://www.reddit.com/r/netsec/comments/es4si/what_are_some_good_netsec_books_out_there/
http://www.reddit.com/r/netsec/comments/g6r71/getting_started_in_network_security_a_list_of/
There's also loads of blogs and websites around, if you go hunting or look at some of these netsec threads, you'll find loads more material.
chrome runs at user app level. it's not running in kernal space with rootkit-like functionality.
Google going out of there way to try and illegally spy on you is crazy. simply because any interested party can go and grab a copy of IDA pro and slap it onto chrome right now and do live disassemble the code base as it's running. Watch the stack calls, view library calls, and view network traffic.
But if the overly paranode type. Then go an investigate for yourself you have access to the tools and the books to self-learn the skills need to do so. Here a good jumping off point
http://out7.hex-rays.com/demo/request < request a trail evulation of ida pro
read this
https://www.amazon.ca/Reversing-Secrets-Engineering-Eldad-Eilam/dp/0764574817
this
https://www.amazon.ca/IDA-Pro-Book-Unofficial-Disassembler/dp/1593272898
and finally this
https://www.apress.com/gp/book/9781484200650
Reversing: Secrets of Reverse Engineering - Is probably the most common book recommendation. Its an older book (2005) but its about as gentle as it gets in terms of the core concepts but its missing a bit due to its age (32bit RE only). I'd liken it to something like Hacking: The Art of Exploitation for exploit developers. Its a solid book, it covers the fundamentals but it'll take a bit more work to get up to speed.
Practical Reverse Engineering - This one is a newer book (2014) while it doesn't cover as many topics as the above book, its less dated in what it does cover, and it does cast a wider net covering things you'll see today like ARM and x64 instead of just x86. I tend to recommend starting with this book, using Reversing and the next book as a reference if there is a chapter of interest.
Practical Malware Analysis - While this one has more traditional RE introduction, where it excels is in dynamic analysis and dealing with software that doesn't want to be analyzed. Now, its from 2012 and malware has changed since then, so its age certainly shows, but again fundamentals remain even if technical details change or are expanded upon.
Practical Binary Analysis - This is the newest book of the list (December 2018). It wouldn't use it alone, but after you've gone through any of the above books, consider this an add-on. Its focus is on dynamic analysis and its modern. I'll admit I haven't read the entire thing yet, but I've been pleased with what I have read.
Edit: s/.ca/.com/g
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
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!
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
Read this, then read this.
You didn't ask me the question, but I'm learning with the same material.
I just finished working through the Big Nerd Ranch Objective-C book and found it extremely accessible and enjoyable. I started the iOS book yesterday and worked through five chapters - if you're genuinely interested in learning Objective-C and iOS these books are difficult to put down. Be aware that the newest edition of the BNR Objective-C is due at the end of November and the iOS book due at the end of December.
Paul Solt's course provides video content that I have found to be beneficial supplementary content to the BNR books. Working through the book along with Paul's course has helped me cement the material. He posted a coupon to take the course for free ~1 week ago. Not sure the coupon is still valid or not.
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
You will not learn C++ properly from internet resources, particularly from bad ones like learncpp. You will need a good textbook, and we recommend C++ Primer (not C++ Primer Plus). And read the FAQ.
Pick up this book for $15 and work through it.
http://www.amazon.com/Objective-C-Programming-Ranch-Guide-Guides/dp/0321706285
This book is written for complete beginners so that you will learn the C programming language on OS X, and then more specifically Objective-C so that you can begin programming for iOS and Mac OS X.
It'll guide you through everything from getting your development environment (Xcode) to creating your first programs. There's also an active forum community at BigNerdRanch if you run into problems, although all of us should be able to help you as well.
In my opinion, not only do you not need Windows, but developing anything in Windows is much more difficult than in OS X. OS X is based on UNIX, which is a big deal for programming, because it gives you access to the terminal and a nix filesystem (which is identical to Linux's – most programmers would suggest you use a Linux variant such as CentOS or Ubuntu, but to be honest Mac OS X is just as viable for programming as any Linux variant).
As far as getting started goes, it's always a good idea to learn the granddaddy of most languages: C, and one of its extensions (C++ or Objective C). After that you're free to learn whichever language you want. Python is a popular choice because it's very simple (and powerful!), but I wouldn't make it your first language if you're serious about programming. Python is almost too simple for its own good. You won't learn many of the common language conventions, which you would* learn if you learned C or Java.
There are a few free C textbooks online, but none are as beginner-friendly and OS X tailored as the one I linked above. As far as development environments go, on Mac OS X there are two important environments: Xcode, which is Apple's own development environment. It will allow you to program in C, Objective C, and NASM. And then there's Eclipse, which is a multi-platform environment that supports a whole slew of languages.
I would think C rather than C++, because Objective-C is basically C with the object orientation from Smalltalk smacked onto it.
My recommendation is to pick up a book. This one (Objective-C Programming: The Big Nerd Ranch Guide) was one recommended by the iOS 5 Developer Cookbook.
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.
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.
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!
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.
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.
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
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.
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".
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.
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.
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.
> How do I learn all the technologies that have emerged out in the recent years?
Slowly.
Read. Books, large projects, small projects, blogs.
I wrote something on PHPUnit.
I wrote something on XDebug.
I wrote something on Composer.
Frameworks aren't for learning how to write PHP. You should already know PHP pretty well before deciding on using a framework. If you try to learn OOP through using a framework you're Going To Have a Bad Time.
Read this to figure out what a framework actually is and what it's for.
If you're not very familiar with how to use OOP, read /u/ircmaxell's blog, from the beginning.
If you need to actually gain more in-depth understanding of OOP, read this and then this.
Depends on what you want to learn.
Web Application Security?
Exploit Development?
"Pentesting" techniques?
Also check here for tons other of resources.
As for certs, if you are a beginner beginner, then probably stuff like Security+ and Network+. Unlike the guy behind me, I will never get, nor do I really recommend CISSP, unless you are going for strictly blue team (defense) work. I personally enjoy red team (pentesting, etc), so something like OSCP would be more useful.
Like I said in a post above, feel free to PM me with questions. I'm always happy to help others on their quest to learn more about the wide world of infosec :)
Network+,Security+,Linux+ = Good.
Udemy i'm not exactly sure about, I have no idea how good it is, however Cybrary does have penetration testing courses on there for free and they're decent.
Grey & Black hat python - Great books. I'm currently looking at black hat python, and it's awesome.
Some other books i'd recommend: Hacking: The Art of Exploitation The hacker playbook 2
While i'm not a professional pentester(YET :P) i've learned alot from the books I listed above as well as the cybrary videos. If you really have the money, I recommend the Penetration Testing With Kali Linux Course From Offensive Security It's fairly expensive, but I've heard it's worth it.
Offensive Security's OSCP should be your goal if you wanna get into pentesting. Start with reading CEH material and The Hacker Playbook http://www.amazon.com/The-Hacker-Playbook-Practical-Penetration/dp/1512214566.
The answer to that is really a bunch of variables that you have to determine yourself. Answer these questions and others I havent thought of and then use them to calculate if its worth keeping:
How much longer am I going to use this code? is it temporary code? are other people using this code? Is coming back to this code in 6 months or a year going to be a nightmare? Am I going to be working with this code often? Is the sloppiness of this code causing other problems or might it in the future, and how serious are those problems? HOW MUCH TIME AND EFFORT WILL IT BE TO REWRITE THE CODE VERSUS ALL OF THE POTENTIAL TIME AND EFFORT THAT WILL BE ADD FROM UNFORSEEN PROBLEMS FROM THIS SLOPPY CODE?
-----
The capitalized part is the final question you can use to decide to rewriting it. Keep in mind its easy to underestimate future headaches from being sloppy.
-------------
Some random basic links on not writing sloppy code:
An EXCELLENT book on the subject:
https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship-ebook/dp/B001GSTOAM
other links...
https://blog.alexdevero.com/6-simple-tips-writing-clean-code/
https://www.butterfly.com.au/blog/website-development/clean-high-quality-code-a-guide-on-how-to-become-a-better-programmer
https://www.pluralsight.com/blog/software-development/10-ways-to-write-cleaner-code
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.
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.
This one I hear is great:
http://www.amazon.com/Refactoring-Improving-Design-Existing-Code/dp/0201485672
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.
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.
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!
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.
> 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.
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.
>how, exactly, things like MVC work in action, and why the little things always end up more challenging than anticipated.
These are things a bootcamp will not teach you.
I just finished this book and it goes over a lot of things like design patterns and how to stay agile, why code rot happens, etc etc. It might help you a lot more than a bootcamp would, and costs about 300 times less.
I found that often the best way to know if your implementation is SOLID is to write the unit tests for it.
For example, if you want to test the PreferencesThing class, you could run into an issue because of the dependency on PreferencesStorage() : if it needs a file, the network, whatever, it will be hard to write. So PreferenceStorage should implement a IPreferenceStorage interface, that you would mock during the tests. And your class constructor or GetThing method would take a IPreferenceStorage parameter. In a strict SOLID approach, I guess that even the ObjectSerializer could be considered problematic.
That being said, keep in mind that SOLID is an excellent way to structure your code, not a magical hammer. Use it wisely.
I would recommend (if it has not been made) reading http://www.amazon.com/Agile-Principles-Patterns-Practices-C/dp/0131857258 which goes in length on those topics. Also, anything else by Robert Martin (uncle bob) is usually a good reference on the topic.
LSU's problem is not budget cuts. Their CS bachelor and masters programs have been unaccredited and very poor for 20 years. Their CS PhD program on the other hand is quite good but that's a completely different entity. (I'm not saying brilliant people haven't graduated from LSU CS, but those people were brilliant themselves and largely could have done without the 4 year term in undergrad since they learned more on the job than in Coates Hall)
SLU, LSU and all state universities are going through budget cuts. I'm on the advisory board for SLU and ULL and in the case of SLU in 2004, 67% of their funding came from the state. In 2014, it's down to only 28% from the state. So, tuition has gone up. The pressure for private donations has risen sharply. But despite this SLU CS revamped the department in 2005 including modern technology into the curriculum, modern theoretical concepts and increased its student project exposure with modern technology and techniques many times over.
So while LSU recently added a class incorporating AngularJS in it, SLU has been teaching students cutting edge technology and theory and technics like SOLID principles, MVC and now AngularJS for a decade now. I was directly involved in SLU continuing their ABET accreditation 6 years ago and wasn't even needed for the 2014 check. SLU is also constructing a new building for CS, despite having build a new for them less than 16 years ago. I don't know how I feel about it but whatever, it's a perk.
The difference isn't money, it's people. SLU and ULL CS profs have LSU profs beat by a country mile. The SLU curriculum is constantly adapted for the industry. The student focus is experience and application of the theoretical techniques. The theory classes will teach you a dictionary is faster than a list and in the project courses, which start sophomore year, you will see why and will never forget it.
Consulting firms cherry pick ULL and SLU junior project presentations for new hires while LSU CS graduates are largely unimpressive until their 3 year maturity.
So snag a used copy of the cs bible and give Doc a call.
Amazon links to the three mentioned books:
Agile Principles, Patterns and Practices (Robert C Martin)
Applying UML and Patterns (Craig Larman)
Art of Unit Testing (Roy Osherove)
Agile Principles, Patterns, and Practices in C#
https://www.amazon.com/Agile-Principles-Patterns-Practices-C/dp/0131857258/ref=sr_1_3?keywords=patterns+practices+in+c%23&qid=1575135541&sr=8-3
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.
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.
From OP:
>The exact four books I read are:
>Learning Obj-C
>Learning Java
>iOS Programming: The Big Nerd Ranch Guide
>Android Programming: The Big Nerd Ranch Guide
>However, I would now recommend learning Swift instead of Obj-C. At the time when I was looking into iOS books, good books on Swift were few and far between.
From u/AlCapwn351 in regards to other sources to learn from:
>www.codeacademy.com is a great site for beginners (and it's free). It's very interactive. W3schools is good for learning stuff like JavaScript and HTML among other things.
>When you get stuck www.stackoverflow.com will be a lifesaver. Other than that, YouTube videos help and so do books. Oh and don't be afraid to google the shit out of anything and everything. I feel like an early programmers job is 90% google 10% coding.
>Edit:
>It's also good to look at other peoples code on GitHub so you can see how things work.
Stephen Kochan’s Programming in Objective-C is great for learning.
To go along with what /u/xXCallMeGreenyXx said, you should definitely learn Objective C before attempting tweaks. I'd personally suggest [this] (http://www.amazon.com/Programming-Objective-C-Edition-Developers-Library/dp/0321967607) because it starts from the basics.
Feel free to PM me though, if you need any help. :)
The book Programming in Objective-C is pretty good, and focuses on the language itself rather than SDKs.
JavaScript: The Definitive Guide. It's long, but very thorough.
Pro JavaScript Design Patterns
http://www.amazon.com/JavaScript-Design-Patterns-Recipes-Problem-Solution/dp/159059908X
JavaScript Patterns
http://www.amazon.com/JavaScript-Patterns-Stoyan-Stefanov/dp/0596806752/ref=sr_1_1?s=books&amp;ie=UTF8&amp;qid=1303912468&amp;sr=1-1
High Performance JavaScript
http://www.amazon.com/Performance-JavaScript-Faster-Application-Interfaces/dp/059680279X/ref=sr_1_3?s=books&amp;ie=UTF8&amp;qid=1303912468&amp;sr=1-3
Object Oriented JavaScript
http://www.amazon.com/Object-Oriented-JavaScript-high-quality-applications-libraries/dp/1847194141/ref=sr_1_1?s=books&amp;ie=UTF8&amp;qid=1303912517&amp;sr=1-1
JavaScript: The Good Parts
http://www.amazon.com/JavaScript-Good-Parts-Douglas-Crockford/dp/0596517742/ref=sr_1_4?s=books&amp;ie=UTF8&amp;qid=1303912536&amp;sr=1-4
Everyone loves to swing from Crockford's nuts, but I found this book a little hard to read. I lack a CS background and I fully admit I need to re-read this book as last time I read it was beginning of 2009
JavaScript: The Definitive Guide 6th Edition
http://www.amazon.com/JavaScript-Definitive-Guide-David-Flanagan/dp/0596805527/ref=sr_1_1?s=books&amp;ie=UTF8&amp;qid=1303912643&amp;sr=1-1
I just ordered this yesterday, the 5th Edition is the book that really kicked it off for me back in 2005.
jQuery is cool and all (as are all the other libs) but you should try to learn core JavaScript as much as possible.
You need to understand there are a couple of ways to do Java web development.
Definitely learn Hibernate. You can start with the JPA material in the Java EE tutorial.
As for design patterns, Design Patterns: Elements of Reusable Object-Oriented Software is a classic. I also like Patterns of Enterprise Application Architecture for more of an enterprise system pattern view of things. Probably avoid most J2EE pattern books. Most of the Java EE patterns come about because of deficiencies of the J2EE/JavaEE platform. As each new version of Java EE comes out you see that the patterns that have arisen become part for the platform. For example you don't create a lot of database DAOs because JPA/Hibernate handles your database integration layer. You also don't write a lot of service locators now because of CDI. So books like CoreJ2EE Patterns can interesting but if you are learning a modern Java web stack you'll be amazed at how archaic things used to be if you look at old J2EE pattern books.
p.s. Don't buy anything that says J2EE, it'll be seven years out of date.
As others have mentioned, writing code is the best way to get exposure. But if you're a book guy like me then there are a lot of option out there that'll accelerate the process. You'd be insane to read all the following--these are just starting points that can accommodate different interests/tastes.
Having said that, I'll start with the one book that I think every C# developer should own:
Framework Design Guidelines: Conventions, Idioms, and Patterns for Reusable .NET Libraries
... it's a good read, and it includes a lot of direct input from the designers of the C# and the .NET Framework. Microsoft has been really good about sticking to those guidelines, so you'll immediately get a leg up on the Framework libraries if you work through this book. (Also, you'll win a lot of arguments with your coworkers about how APIs should be designed.)
General knowledge books (tons to pick from, but here are some winners):
Deep dives into specific features that'll serve you well:
Note: I've never found a good LINQ book that supported how I actually use the feature. Coming from C++, you can probably just start off by thinking of the extension methods on Enumerable as a C# version of std
&lt;algorithm&gt;... a good way to avoid writing raw loops. But if you're a performance-obsessed game dev then you'll probably want to use LINQ sparingly--it does have some overhead.No problem. I am by no means an expert in writing code or buffer overflows but I have written several myself and even found a few in the wild which was pretty cool. A lot of people want to jump right in to the fun stuff but find out rather quickly that they are missing the skills to perform those tasks. I always suggest to people to start from the ground up when learning to do anything like this. Before going into buffer overflows you need to learn assembly language. Yes, it can be excellent sleep material but it is certainly a must. Once you get an understand of assembly you should learn basic C++. You don't have to be an expert or even intermediate level just learn the basics of it and be familiar with it. The same goes for assembly. Once you get that writing things like shellcode should be no problem. I'll send you some links for a few books I found very helpful. I own these myself and it helped me tremendously.
Jumping into C++: Alex Allain
Write Great Code: Volume1 Understanding the Machine
Write Great Code: Volume2 Thinking Low-Level, Writing High Level
Reversing: Secrets of Reverse Engineering
Hacking: The Art of Exploitation I used this for an IT Security college course. Professor taught us using this book.
The Shellcoders Handbook This book covers EVERYTHING you need to know about shellcodes and is filled with lots of tips and tricks. I use mostly shells from metasploit to plug in but this goes really deep.
.
If you have a strong foundation of knowledge and know the material from the ground-up you will be very successful in the future.
One more thing, I recently took and passed the course from Offensive Security to get my OSCP (Offensive Security Certified Professional). I learned more from that class than years in school. It was worth every penny spent on it. You get to VPN in their lab and run your tools using Kali Linux against a LOT of machines ranging from Windows to Linux and find real vulnerabilities of all kinds. They have training videos that you follow along with and a PDF that teaches you all the knowledge you need to be a pentester. Going in I only had my CEH from eccouncil and felt no where close to being a pentester. After this course I knew I was ready. At the end you take a 24-long test to pass. No questions or anything just hands on hacking. You have 24 hrs to hack into a number of machines and then another 24 hours to write a real pentest report like you would give a client. You even write your own buffer overflow in the course and they walk you through step by step in a very clear way. The course may seem a bit pricey but I got to say it was really worth it. http://www.offensive-security.com/information-security-certifications/oscp-offensive-security-certified-professional/
> 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.
> 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.
I learned Java in the late 1990s from the first edition of Learning Java and also some of the official online tutorials. I just fooled around with it a short bit. I relearned Java some years later from Head First Design Patterns and Effective Java. The Patterns and Effective books really help you design your classes. Ps: I know nothing about Android programming.
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
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.
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
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.
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 :
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.
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 )
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.
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.
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.
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 you think Uncle Bob is a recent CS graduate?
He authored this book
https://www.amazon.com/Clean-Coder-Conduct-Professional-Programmers/dp/0137081073
That what who8877 wrote and this book are my recommendations for you.
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
Hey mate, I found that the philosophy of stoicism allowed me to really appreciate what I work on (even those crappy legacy systems). Here is a good primer http://www.goodreads.com/book/show/5617966-a-guide-to-the-good-life.
You said that meditation helps, well I think that a good philosophy for your life can build on that.
You have some awesome savings and at least that is something to appreciate!
Edit: Oh there are also some great tips on "workaholism" and the art of saying "no" in the clean coder by uncle bob (https://www.amazon.com/gp/product/0137081073/ref=as_li_tl?ie=UTF8&amp;camp=1789&amp;creative=390957&amp;creativeASIN=0137081073&amp;linkCode=as2&amp;tag=nodogma-20). It is quite a common problem in our industry that we are overworked, but it comes down to our professionalism and standing up for ourselves and making sure that we don't make false promises. The worst thing that could happen to you if you start leaving on the clock and saying no to ridiculous requests is that you get fired and get to take that sabbatical!!
Data Structures and Algorithms in C++ by Adam Drozdek - Pretty much helped me survive my Data Structures class
[Refactoring: Improving the Design of Existing Code by Martin Fowler]
(http://www.amazon.com/Refactoring-Improving-Design-Existing-Code/dp/0201485672) - Serves as my go-to book at work, right next to Design Patterns.
I have to say linux profiling has seemed to me to be a fast-moving target, meaning you'll get scattered results if you search. But, there's this which seems up-to-date: http://en.wikipedia.org/wiki/Perf_%28Linux%29
Then there's Ulrich Drepper's 'What every programmer should know about memory' (long series, but worth skimming at least, if your code is memory intensive. At least read about cache-coherency and cache-lines): http://lwn.net/Articles/250967
But the biggest thing is to get the algorithms right. Sounds like you want image-processing books. Also, GPUs are just absolutely the right place to do this stuff, and there are probably libraries already out there for it; speaking of which, did you know about OpenCV? It even has some stuff implemented on the GPU (as CUDA). I root for OpenCL, but the fact is, almost everything out there, libraries, and books, is written for CUDA.
> All the software is written in C++: I am interested in unlearning bad habits and writing better and easier to maintain code.
I suggest Effective C++ if you haven't read it yet. Also, Herb Sutter's 'Exceptional C++' series (a 'digest' version is C++ Coding Standards: 101 Rules, Guidelines, and Best Practices).
Never read it myself, but I hear 'Code Complete' is good. Maybe, too, Martin Fowler's Refactoring book - it shows lots of little awkward, problematic patterns and what to do about them, with good discussion. Each cleanly separated out - it will refer back and forth, but you can read the bits one-at-a-time. Good bathroom reading :)
Re: algorithms: Ugh, I don't know. It sounds like you'll want some metric data structures, dealing with space as you do. There's http://www.amazon.com/Foundations-Multidimensional-Structures-Kaufmann-Computer/dp/0123694469, and I don't know what else, maybe some Knuth? But probably, you should learn undergraduate-level data structures and algorithms, Big O stuff. Any used CS Data Structures + Algorithms book should help with that.
Do not fear spending money, as a former boss said, "books are free" ie they pay for themselves if they save you an hour's debugging later. Good luck!
I've found that I gained most of my best experience on the job, and that staying at a job where I wasn't learning anything was a huge mistake and detriment to my career.
That said... I don't think I'm a super genius either. I did well in college and my GPA helped with my first few jobs. But I have lots of hobbies outside of work, and rarely spend my time at home thinking about the office. A lot of times companies aren't looking for the super genius type either... if they were they'd have a hard time filling staffing requirements. I think the keys are learning how to interview well, focusing on letting the interviewer know that you're willing and good at learning and having the basics of OOO down to a T. Come off as confident, even if you don't feel it. It never hurts.
As far as books go, here are some of my favorites:
Programming Interviews Exposed
Programming Pearls
Refactoring
I'm mostly a java programmer, so here are three absolutely necessary java books:
Head First Design Patterns
Core Java 1
Core Java 2 - Advanced
My favorite book is Refactoring by Martin Fowler.
http://www.amazon.com/Refactoring-Improving-Design-Existing-Code/dp/0201485672
Have you ever heard of the open/closed principle? Or the single responsibility principle? Or Liskov substitution principle? All three are being violated. It drastically reduces the maintainability and extensibility of your code. I can't swap serializers easily, i can't tweak or extend them without touching that huge class and it's definitely not the responsibility of that class to know how to serialize A, B, C, D, E and the whole alphabet.
I highly recommend some literature on the subject if you're curious about it, it would drastically improve your approach to software architecture:
https://www.amazon.com/dp/0132350882
https://www.amazon.com/dp/0201485672
https://www.amazon.com/Domain-Driven-Design-Tackling-Complexity-Software/dp/0321125215
http://cc2e.com/
https://www.amazon.com/dp/0321127420
Refactoring
What you do is called refactoring and it is a good thing to do as long as you don't do it instead of planning ahead. But often time you can't plan out every little detail and then it's the right thing to do some cleaning once you have a working implementation.
Martin Fowler wrote a whole book about the topic (which is very good btw): http://www.amazon.com/Refactoring-Improving-Design-Existing-Code/dp/0201485672
Objects are for grouping related data and methods together. It really is as simple as that.
Start off by writing applications where you're just creating and consuming objects, not writing your own classes. Java and .NET both have tons of libraries that contain a wide assortment of objects. You mentioned C#, so write a few .NET apps. Try to start identifying and understanding the way properties and methods are grouped into objects, and how the different objects relate to each other.
Once you're comfortable using objects, then you can start writing your own classes. A lot of universities try to teach this by having you write common data structures. This approach is worth considering, as it's important to be familiar with data structures, but this isn't the only way to learn object-oriented programming (nor the best, in my opinion). Another commenter recommended writing a video game, which sounds like it's worth a try. Ultimately, the right approach is the one that interests you the most.
Getting good at OOP will take some practice, but it is possible. Objects are like functions: they should do one thing well. Enforce separation of concerns. Learn the design patterns. Practice makes perfect(-ish).
Recommended Reading:
As others have mentioned you need tests.
If you can't write tests at all because the way the code is put together then the first step is to untangle things. This can be hard. If your code is working I'd probably just leave it alone until you need to touch the code for some other reason (adding a new feature, usually).
I recommend this excellent book for learning about specific ways to refactor, as well as when they are commonly used: http://www.amazon.com/Refactoring-Improving-Design-Existing-Code/dp/0201485672
strictly speaking, it depends on the language, but probably you don't understand objects. given that you're in Python and it's got OO (or close enough), I'm going to escalate that from a probably to a very very probably. basically, if you move the stuff inside the ifs into methods on objects, in the absolute simplest case, you'll put each if inside a different object, and then your huge chain of ifs turns into:
object.method(arguments)
And instead of throwing all those ifs in there, you basically run through all the ifs ahead of time by just giving that block of code an object of the appropriate class.
The absolute best book on OO (in my opinion) is Refactoring.
http://www.amazon.com/gp/product/0201485672?ie=UTF8&amp;tag=gilebowk-20&amp;linkCode=xm2&amp;camp=1789&amp;creativeASIN=0201485672
I have a feeling the Head First book on OO is also very, very good. I haven't checked it but the series is a great series.
Refactoring: Improving the Design of Existing Code is ok. I don't know if it is as amazing as the reviews think, but it is pretty good. It is a little Java centric.
You really don't see many blog posts/internet articles about refactoring. It almost sounds like you are looking for help with design, refactoring is just the process of how to reach a better design.
The most important part is to write unit tests to make sure that you preserve the required behavior during refactoring.
Yours is better. You eliminated the temporary variable which is a very good refactor. Performance wise yours is better (for same reason) unless the compiler optimizes away the temp variable, then they are the same.
For some reason code that uses temporary variable like theirs takes me longer to read.
I will recommend the book refactoring by Martin Fowler.
If you're 4 years into your career and you haven't been failing at it and getting fired, you probably don't need to go all the way back to the absolute basics. You just need to fill in holes and keep pace with change.
I like to read books/blogs on emerging technology and areas becoming relevant. Like I just read [Refactoring: Improving the Design of Existing Code] (http://www.amazon.com/gp/product/0201485672) because we were doing a huge refactoring project at my job. I read Ng-book and an .NET MVC right when I got my current job because I'd never worked with angular or MVC before. I'm currently looking at some stuff about .NET Core. It won't be relevant at most places for years, but it's nice to keep on the edge sometimes.
Blogs are also good things to read too. The Morning Brew is my favorite site right now for keeping up with .NET.
If you're worried about your fundamental skills I'd say work through something like codility. I think you'll find a lot of the problems trivial or easy to pick up and do with a little googling. Sites like this are usually the kind of questions you'll get asked in interviews, so if you can do them, then you're fine on that front.
Break your main up into multiple smaller methods, and call those from your main method.
When doing this, the naming of the method is important. The name of the method should describe what the method does.
The cookSpaghetti is an example of this. The method name says what the method does, not how the method is doing it, which would be an unnecessary detail at that point.
When you structure your code like this, it will almost read like a story, which will make the code much clearer.
The Refactoring book provides more ways to improve the quality of your code, although it might be too advanced right now.
It's a search algorithm which divides up the solution space using binary search.
See Programming Pearls by Jon Bentley for an interesting investigation of the ubiquity of binary search.
Programming Pearls
In college, I probably wouldn't have cared and had it end up as a fluff class (if it got offered at all, academia is notoriously different than the industry). There was far too many other things to learn. As it was I took intro, mips assembly, digital logic, data structures, compilers, operating systems, theory of programming languages (imperative and functional), theory (the regex to Turing machine), AI, and numerical methods - and that filled up all of my CS degree requirements.
In the mean time, I've found a few books that do capture some of this philosophy. Probably the best is Programming Pearls, though there's some in The Mythical Man Month too. (And yes, this time it is something I wrote...) my list of Five books every programmer should read captures some of that.
The post Ruby’s Principle of Too Much Power is a good read about what happens with too much power.
I do suspect much of this comes from our generation and the code philosophy we (or at least I) was brought into back in college. From that W3 link:
> Computer Science in the 1960s to 80s spent a lot of effort making languages which were as powerful as possible.
More powerful languages to hide the complexity more. C++ and Java came into the world with the idea of encapsulation and private variables - OO coming into vogue. Everything was "more power" (and I have Tool Time flashbacks here). It took two or three decades to come to terms with "too much power is not a good thing."
... and yes, this is finding its way to a blog post of my own.
Expert C Programming : Read this after reading K&R C book.
Programming Pearls : Excellent Book
Algorithm design manual : Read it after CLRS.
A lot of good mentions here. Although they're more programming and engineering than "computer science", I would add Design Patterns by the Gang of Four, and
Programming Pearls by Jon Bentley.
Programming Pearls by Jon Bentley
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
If you want an excellent whirlwind tour to computer science basics with a language you've probably never heard of, I'd recommend MIT's Structure and Interpretation of Computer Programs course. The video lectures and the course book are available free online. It's pretty tough going but will seriously expand your mind :)
For design stuff I'd recommend reading books about OO testing and refactoring, like this or this.
This pretty much defines the TDD workflow. It's exactly as mr_chromatic describes it.
Try Test-Driven Development. In TDD, programming proceeds by accumulating ever larger catalogues of concrete examples. Get hold of Beck's Test Driven Development: by example Get your buddies to set you up with a TDD environment in Ruby and off you go.
http://www.amazon.com/Test-Driven-Development-By-Example/dp/0321146530
Yes, his book is titled "Test Driven Development: By Example".
Hi here's the link - https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882 it has made a huge difference in how I code. If you can get your hands on the video that's even better. They are hilarious.
I really recommend a book Clean Code by Robert C. Martin. It can really help you understand how to write clean code, which you can use and improve right away.
I can't recommand enough this excellent book : https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882/ref=sr_1_3?ie=UTF8&qid=1539318206&sr=8-3&keywords=clean+code
Ok, then I would suggest the following ones:
Besides Books you can also find good artciles on the net about OOP basic principles like SOLID.
Actually I loved the Design Pattern book for showing me, that the basic principles are really the core of OOP. Of course they rely on the building blocks (Abstraction, Inheritance and Polymorphism), but they show you, how you should use those and make advanatge of them in order to build clean, resuable and maintable software. The latter on of the books focuses more on those principles, which is also nice.
I'll start by saying if you haven't read Clean Code, then it's a great place to see questions like your answered with examples. It gets a little too in the weeds for some people at the end, but the first several chapters are great for explaining how, why, and when to break things up.
What a lot of it comes down to for me (and there are different opinions on what "clean" code looks like or should look like, it's somewhat stylistic) is readability.
No matter what app you're writing, with a little bit of business/domain knowledge I should be able to look at your code without having seen it before and be able to understand what parts of the code are responsible for what logical operations so that if the requirements have changed or a bug was found I should know right where to go.
I made a small example while nomming some lunch (forgive me for typos or obvious errors lol). The example is a Cash Register app that is responsible for totaling the sale amount given a list of items.
___
Here is the orignal code | Here's the refactored Specifically looking at the CalculateTotalSale methods....
So in a small trivial program it's not as easy to see the benefits, but in the refactored version the total sale logic has been broken up into methods. This way, lets say there's a bug in how we're calculating taxes (in a small app like this they're probably wouldn't be, but in an enterprise POS app that's in an international market tax calculation can be a pain) we've made several ways to track down where taxes are being done. We can look at the usages of _taxes to see where it's being modified, and we can look at CalculateTaxes() method since that's where all the tax logic should be. If we find that tax logic is not there, we should either move there, or consider a small change in design to make it flow easier.
Also we've left the CalculateTotalSale method open for extension as well. Noted by the comments, if the business wanted us to write coupon logic we could put it in it's own method and go from there. We've left a pattern for the next person to follow, they'd be able to get into this code and get to work pretty quickly. Patterns do change though, but since we've followed some fairly fundamental designs of class structure it'd be easy for someone to change the pattern if they needed to. They won't have to look all over the code for pieces of logic if we've grouped it well.
All that being said, the first example still works fine and gets the job done, the discussion above is more of engineering vs programming. Just my two cents though! Sorry if I've made any obvious errors or didn't explain this well!
Jajaja salta a la vista no?
Comentarios igual te los paso... pero que te encuentres un metodo asi de jeta llamado ersteIndexprufung ponele en vez de firstIndexVerification.
Ya vi cosas como var variavel1 , function asdfg
Ya que hablamos de todo esto:
https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
It might be. There's the issue of making things work, then the issue of writing clean maintainable code that others can understand. A good engineer needs to be able to do both. For something like Java or C#, check out SOLID principles. There's also a book called Clean Code which might be helpful.
Clean Code Books:
Design Patterns:
And of course, good ol’ practice.
My ultimate goal at the moment is to move into a digital nomad type role doing mobile development, preferably for Android.
So, my invisioned path from here is to buy or download some books on Android development and start learning. I've located what seems like a good source (of sources) for learning about Java/Android here, (taken from here)though I don't know because I haven't the links yet.
What is a good (and free) Java / Android Development courses online? Anyone have an opinion on Google's?
Does this path seem good? Should I be considering Java and Android Development the same thing? Thank you!
Clean Code
Clean Code: Clean Code
Clean Architecture: Clean Arch
&#x200B;
Just picked these two up myself.. not sure if its what you are looking for, but seem to be very valuable for software design as a whole.
I would recommend reading a book like Clean Code. It talks about writing high quality and structured code.
Python is great for intro, I say keep at it.
Definitely pick up some books or youtube tutorials if you're struggling with certain concepts.
If you're worried about your code being messy, check out pep8 it's basically a formatting guide for python.
And to take it a step further check out [clean code] (https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882) its a little thicc, but it does wonders for code readability.
Also recommend once you get the hang of python, check out Java. IMO it exposes a lot of those underlying concepts more so you'll understand some of the underlying mechanisms in what you write.
Note that rarely using comments isn't necessarily a bad thing
take a look at this
get_date_of_birth(person):
#return the date of birth for a given person
get_date(person):
Which one reads better?
You'll learn this if you read Clean Code, but code is for humans. What you write will be read by humans, it gets compiled down / interpreted into machine language for computers but as far as anyone seeing your code it will be humans.
edit: forgot about md formatting
I would recommend reading Clean Code. It is a good, easy-to-read book about how to write quality code. It can help you a bit for all your languages.
Other than that, perhaps you could helpan open source project? Then you get real coding practice.
I like Clean Code by Robert C. Martin.
This great book hammers the point home that, as a programmer, you are an author. So I'd say your education and teaching experience are an excellent starting point. Read the book and be prepared to reason about why you care about code quality. Any potential employer who cares about the future of their business should pick up on this. Be upfront about your (lack of) experience and show that you want to learn. Work on a portfolio of personal projects: noone expects a newbie to have indepth library knowledge, but experience does count.
Some highly recommended books:
Bonus JS Book: JavaScript: The Good Parts
Note: Software development is a very wide field. You don't need to learn everything, it's okay to focus on your strengths. Don't be discouraged if you find a particular subject too difficult to learn.
Heh, sure.
A lot of people are fans of Code Complete. I tried reading it after being in industry for a decade, and I found it to be very dry and boring. The general consensus from people that I've talked to is that it's more useful when you're just starting out. Maybe I just came to it too late.
A better book (in my opinion) in that same vein is Clean Code. Clean code is shorter, more focused, and has better real-world examples. It feels less "complete" (hue hue) than Code Complete, but to me, that's a strength. As a quick point of comparison: Code Complete devotes 32 pages to the chapter on identifier naming; Clean Code devotes just 14.
I got a lot out of Design Patterns. I seem to recall that the pattern fad was in full swing back when I read this in 2005-ish. I think I had independently discovered some of the patterns already at that point, but this book helped me to codify those ideas and also showed me some new ones. Some of these patterns are now seen as antipatterns (I'm looking at you, Singleton!), and all of the patterns have an object-oriented bias. But there's still something useful in the pattern language, and this book is a reasonably comprehensive start. The book is somewhat dry, and some people report that Head First Design Patterns is a gentler and friendlier introduction. Head First Design Patterns hits the essential patterns, but misses a lot of the less popular ones.
Eventually, you'll need to work in a codebase with some technical debt. Maybe it's debt that somebody else put there, or maybe it's debt that you introduced. Working Effectively with Legacy Code is still my go-to recommendation. It defines technical debt as code that is not under test, it introduces the idea of "seams" that you can use to pry apart code that's too tightly coupled, and it then provides a cookbook of specific scenarios and reasonable approaches.
If you're looking for thought-provoking videos, I recommend anything by Rich Hickey. I don't know if I've watched all of those, but I remember good things about Hammock Driven Development and especially Simple Made Easy.
Get comfortable with a source control system. I didn't use source control in college, since it wasn't needed for any classes, and that was a missed opportunity. The whole world loves Git, so you'll probably want to learn it if you haven't already. But I'll also toss out a recommendation for Mercurial. I haven't used it in years, but I remember finding it to be quite good.
Good luck!
Buy Clean Code and read it before going to bed, or during lunch hour
Are you referring to this?
Probably. It might take some refractoring, but you would need a SaaS like Parse to handle the cross platform sync. I never tried Parse, but I don't want to since it costs money after a certain quota. I've heard some horror stories of independent developers messing up their Parse and blowing through their quota as they failed to put a kill-switch.
Same. I started this project around November to learn Android development. I have a year off before I start college, so I thought of learning some software development. My only experience at the time was high school computer science using C#, so even if you are learning you can contribute. :) Even if it's intimidating you can contribute by submitting issues and such. I contributed to a small database library which was over my head, but I browsed the source to find out how to do something, found an typo in the SQL, and submitted an issue explaining the problem and how to fix it: he forgot a letter.
Although I started learning programming in 2014, if you need any advice on learning Android development, you can PM me. I can provide a list of books you can find online which are helpful for learning Java:
All these books are sectioned such that you only need to read parts you want to, so they are very good references. These books really helped in knowing the syntax of a language and knowing how to use the language which I found was very important for a project of this scale. My first version of it was so hacked together that it was impossible to refractor to add new features. These books really helped for the second version even though I couldn't apply what the books advised effectively.
This book explains fairly well what many professionals consider 'clean code'.
Stay true to OOP and keep in mind the writings of this book, and i think you will avoid most major setbacks.
source: https://www.osnews.com/story/19266/wtfsm/
book: https://www.amazon.es/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
You always want processing. You may or may not need graphics. I saw you say you liked fighting games. You'll need a decent rig with some capable graphics.
You wanna dev?
First, yes you need a machine, a decent one. Do you want to build it? Yes , but if not then check these out. I suggest getting a workstations because they're built for productivity. However, they're expensive.
Also, I'm not sure you should commit to a desktop. Two words: Game Jams. You might want to take part in communities involved in game making games. For inspiration, mentorship and just overall fun. If you're not familiar, games jams are when developer enthusiasts get together and build a game over a period of time. The games tend to be simple and set around a theme for the event.
In which case, look at some cool laptops. The reason I suggest getting a gaming laptop is that it will have the graphic card you need, it doesn't need to be high end, just good enough to not be a toaster. Also gaming laptops tend to be more powerful.
So from a dev point of view, they're pretty solid. Personally, I prefer workstations. If you asked me, I would get a workstation with a video card, but those are very expensive and maybe when you master your craft you can drop some real cash on it. You're new. So don't spend too much, in case the entire thing doesn't jive with you. Worst case you get a decent gaming laptop to play MK at the coffee shop. (Don't laugh, I used to play Street Fighter at a coffee shop, it's a nice vibe!)
Also, I would also check out Meetup.com. Your city or area might have groups dedicated to building games and maybe you can learn with another person. From a professional point of view, there's a lot of value in learning to work with others.
So you got your hardware, now for software.
You will likely want to start building stuff. But you're going to need some baseline stuff.
So, I say go with Unity, long term. However you need to get to a place to understand unity. So... you're going to need to learn some coding. To at LEAST be comfortable with code. I say learn the basic and intermediate stuff first then jump into Unity. If you're feeling bold you could also do the advanced.
You will need only Visual Studio and make sure during the install you ask to include Unity.
Finally, you should read Clean Code. Write good clean code. Future you will thank you.
Now, you gotta be productive.
Set up time to do what you want to do. One or two hour blocks. Commit to them. Log that time. Also, get open office, or some other equivalent and start organizing your workflow. as a develop you need purpose in your tasks. So outline your tasks. Develop you "method" for working. Maybe you like self imposed crunch where you just throw on music and go. Maybe you prefer small bursts of productivity. Whatever it is, figure it out.
Journal your work. Go back and read it occasionally. Take non-digital notes on important stuff you learn. Writing helps with retention. You have two processes you need to flesh out.
You're going to need to get a good sense of how to build a proof of concept. This will help you "feel out" your game's mechanics.
Over time, you will need to explore more advanced idea in computer science like data structures and design patterns... but for now, focus on getting comfortable with code, debugging. Hell, even make a console app text adventure game. Start there. Then get more complexity. The idea here, is to take your time, be diligent and stick to it. Slow isn't bad, not completing is bad. So take your time and good luck!
this is a free python book
https://automatetheboringstuff.com/
figure out how to rewrite all the programs to use java
especially chapters 11 through 17
see if you can find an inexpensive version of this book
https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
read it, learn it well
Have you checked out Robert Martin's 'Clean Code' book and/or videos?
I've found Martin's material to be very helpful in actually identifying the attributes of clean code (and conversely, code smells). His examples are all in Java, which would be good for you, given your Java background. Despite his focus on Java and OOP more broadly, I think the fundamentals of clean code are language agnostic and there is plenty of carry-over to Go. He starts with rules around naming things and moves all the way through higher level design principles.
Fair warning though -- Martin goes totally overboard with props, green screens, theatrics, and astronomy history lessons in his videos. The book is more concise, but I'm a better visual learner, so after reading the book I started going through the videos.
Not sure if it exactly follows this situation, but one of the best books I've read - helped me develop some good habits. Highly recommend.
Clean Code: A Handbook of Agile Software Craftsmanship https://www.amazon.com/dp/0132350882/ref=cm_sw_r_cp_api_irVJzb23P5CQ3
Let me start by saying good code is code that solves the business problem at hand. For someone that really cares about internal quality of software that was a hard thing to accept.
You didn't quite define what you mean by "good" in your question, so I assume you mean adherence to SOLID principles. I've long thought like this too but realized adherence to some metric by itself is not very helpful, exactly because you end up in situations where your code is overdesigned, or worse, has the wrong abstractions.
What helped me figure out where the line is was stepping away from SOLID and focusing on Test Driven Development (TDD). TDD is great because it forces you only to write as much code as you need, not more not less. But in order to write testable code you'll have to apply SOLID principles. So you end up with code that reaches just the abstraction level you need to solve the business issue you're trying to solve.
The interesting aspect of this is that there's no clear universal line you can draw and say "this is too much design!" or "this is too little!". What I've observed is that there's just the right amount of design, and interestingly that's, at least in my opinion, a function of how much change you expect. Writing a 100 line hack to do something that you'll never change again is perfectly good code - it does what you need it to, it has certainly no wrong abstractions or over design. But as with most software, change is inevitable and with change internal quality becomes more important. If your code has good internal quality changing it is easier. The better the internal quality, the easier, within limits. So finding the line is an interesting exercise to balance the cost of design vs the expected rate of change.
If I may recommend some reading here:
Couple must reads:
http://www.amazon.com/gp/aw/d/0321503627?pc_redir=1408680419&amp;robot_redir=1
http://www.amazon.com/gp/aw/d/0321127420?pc_redir=1408765483&amp;robot_redir=1
http://books.google.com/books/about/Domain_Driven_Design.html?id=hHBf4YxMnWMC
I realise this isn't free but Growing Object Oriented Software Guided by Tests is the best book on testing and OOP that I've ever read. I highly, highly recommend it.
Cool :)
I would start with CD book https://www.amazon.com/Continuous-Delivery-Deployment-Automation-Addison-Wesley/dp/0321601912
Having read it you would understand how modern software development look like and you should understand why test automation is crucial these days.
I had once created a post about learning test automation - you can check it here
http://www.awesome-testing.com/2016/08/how-to-start-learning-test-automation.html
Here are two paths I proposed:
Path 1 - GUI Automation with Selenium
Path 2 - REST API Automation with Rest-Assured
There are a couple of testing books which are worth reading too. Perhaps this one is the best https://www.amazon.com/Agile-Testing-Practical-Guide-Testers/dp/0321534468
Just start small with basic checks. You may even use my github project https://github.com/slawekradzyminski/AwesomeTesting
Hope I hadn't overwhelmed you :D
A properly implemented deployment cycle should be a press-button operation. Every environment, including production, should be able to be updated (and rolled back if necessary) unattended and automatically.
I highly recommend this book to anyone presently babysitting deployments.
Read:
https://www.amazon.com/Continuous-Delivery-Deployment-Automation-Addison-Wesley/dp/0321601912
Yeah, so do I. Beck is one of the original proponents of unit testing (and TDD), and this book is a very strong starting point.
After this, I would definitely look into reading something about integration/end2end testing and continuous deployment, like Continuous Delivery. We recently had David Farley do a talk at our work, and he has some very important things to say.
I'm a software developer with about 5 years of experience , and I used to have the same sorts of problems where I would over-commit to getting work done and under-deliver. To summarize, I changed to where I only commit to tasks that will take 1-2 days or less at a time, and I make it very very public what I'm working on in order to manage both my and my team's expectations. Here are the gritty details (ymmv of course):
Side note: in general I limit my work in progress (WIP limit) to one large task and one small task. If there are production issues or something I break my WIP limit by 1 and take on a third task (it has to be an emergency like the site is down and we are losing money), and I make sure that whatever caused the WIP limit to break gets sufficient attention so that it doesn't happen again (usually in the form of a blameless postmortem ) . If someone asks me to work on something that will break the WIP limit by more than one, then I lead them to negotiate with the person who asked me to break it in the first place, because there is not way one person can work on two emergencies at the same time.
Here's some books I've read that lead me to work like this
As you may notice, the latter 3 books are mostly about how to quickly and reliably ship software. Developer workflow is a big part of getting that to happen, and many people have some of the same problems we do.
I could go on like this for hours because I fucking love kanban. Feel free to PM me if you want to chat about your specific problems. There is figuratively nothing that I would rather talk to internet strangers about.
So the difference between 1 and 2 is basically two different modes of delivery. 2 is the traditional large version changes. You'll see this with Adobe CC products, and other large software projects with larger teams.
1 is what you will see with like Chrome, Firefox, and other projects where you might not be aware that an update was made, but still see bug fixes and new features as you use them. This is the continuous delivery model.
1 will require a lot of automation, and a very good CI/CD platform setup. There are plenty of resources around how to get that setup properly. You can always start with versions, and then move into a CI/CD continuous delivery model when your automated process is more fleshed out.
https://www.amazon.com/Continuous-Delivery-Deployment-Automation-Addison-Wesley/dp/0321601912/ would be the resource for CD.
As for your other question, yes I have been working professionally as a QA team lead and/or Manager for almost 10 years now. My focus is really automation testing, but I have worked with many companies setting up QA and SDLC processes.
Hi and sorry for the late reply! The first thing I'll have to ask is what environment are you deploying into, a manually configured virtual machine/bare-metal machine, Heroku, Ninefold? Each of these environments have different (sometimes vastly different) considerations when it comes to deployment of any application. In general though, here's some things that will apply that will apply to any good deployment process (some of what's below echoes /u/codekitten's reply):
Rails.application.config.secret_key_base, I will always use environment variables coupled with something like dotenv or direnv to also manage the configuration for my local development environment.rxsharp.herokuapp.com) will respond to HTTPS, but it's up to you to ensure your user's will always use SSL. Rails has the force_ssl setting to do this automatically for you, which you should have turned on in all of your production and production-like environments, but you should also be using HSTS to ensure that your users always visit your site over SSL (force_sslperforms a permanent redirect tohttps://rxsharp.herokuapp.combut does not set the HSTS headers). The gem that I use most often to take care of setting these headers for me is secureheaders, which also helps you configure a number of other security headers like Content Security Policy headers.curlto hit a status page on your site that returns the currently deployed revision, and rollback the deploy if it receives an error. It can also be as complex as running a suite of RSpec examples that utilize something like Serverspec to assert the state of each one of your application servers (obviously this one doesn't work as easily in environments like Heroku). In the end, the important things here is that you automate EVERYTHING when it comes to your deployments.cap production deploy:migrations, notcap production deploy. On Heroku, you need to run them manually after you deploy using something likeheroku run rake db:migrate. One further topic here that I highly recommend you explore is that of zero-downtime migrations. A great introductory article on these is Rails Migrations with Zero Downtime over at Codeship.These things are all general items that belong near the top of any checklist for deployment (Rails or otherwise). Hope this helps!
If you've not got a copy of Continuous Delivery bu Humble and Farley I'd really recommend it. It's chock full of best practices with reasons as to why, what etc.
https://www.amazon.co.uk/Continuous-Delivery-Deployment-Automation-Addison-Wesley/dp/0321601912
Sometimes it's easier to point to something that's published rather than have it seem like it's just your opinion I've found. :)
No problem.
1.) Is there any option to avoid Windows cause I didn't really grew on it and Linux is much more familiar to me, I can install powershell as a snap I think but I want avoid Windows as much as possible
&#x200B;
I'm the opposite: grew up on Windows and I avoid Linux haha.
&#x200B;
That said, there certainly is the option to simply ignore Windows (there are a lot of Linux only shops out there), however, I would not recommend avoiding it completely.
&#x200B;
Most IT environments that you will end up in have a mix of Windows and Linux. You will be much more attractive to some employers if you can say that you know Windows basics and are comfortable navigating the platform, rather than saying that you are Linux only.
&#x200B;
To add, a lot of enterprises run Windows only tools (ActiveDirectory, Team Foundation Server, etc.).
In order to interface with these tools, you'll need to know some Windows basics.
&#x200B;
At the end of the day, keep in mind that when looking at an enterprise sized network, the operating systems are just one piece of the puzzle. You'll want to be able to step back, visualize the entire network, and not really care what OS is running on the nodes. You'll want to know about the protocols the servers use to communicate (http(s), smb, ftp, etc), how to automate processes regardless of platform, and some basic security concepts.
&#x200B;
2.) What cloud experience should I pick first, I have small budget of 13 euros for Udemy courses so I can pick only one and I want to do it wisely
&#x200B;
Go with AWS 100%. They are the most popular at the moment and a lot (if not most) of what you learn will transfer to the other providers.
&#x200B;
Try to study for the AWS Solutions Architect certification.
&#x200B;
The practice exams here ( https://www.whizlabs.com/cloud-certification-training-courses/ ) are invaluable since they will explain why certain answers are correct/incorrect.
&#x200B;
3.) Would learning Apache, PostgreDB/mySQL be worth ?
&#x200B;
At the end of the day, Apache is basically a web server and the other are databases.
&#x200B;
For a DevOps role, perhaps look into automating the database component of an application deployment.
&#x200B;
4.) Which should I pick first to learn about concept
&#x200B;
Look into CI\CD pipelines. CI = Continuous Integration and CD = Continuous Deployment.
Basically, these pipelines deploy an application to web servers when developers check in their code.
One has to build them using different tools. Have a read here ( https://semaphoreci.com/blog/cicd-pipeline ).
If that interests you, this is basically the Bible on CI\CD ( https://www.amazon.com/Continuous-Delivery-Deployment-Automation-Addison-Wesley/dp/0321601912 ).
&#x200B;
Any more questions feel free to ask.
I would highly recommend just diving in with Objective-C. Skip all the other languages - they'll just slow you down. The Big Nerd Ranch Objective-C Programming book is an excellent way to get started with programming in general, and you get to learn Objective-C (of course). Here's the link: http://www.amazon.com/Objective-C-Programming-Ranch-Guide-Guides/dp/0321706285
I've written a bit more on my blog based on my experience - it's a bit different from yours, since I already had Java experience when I learned Objective-C, but you certainly don't need to learn another language first. Here it is: http://roadfiresoftware.com/2014/03/can-i-learn-objective-c-without-knowing-c/
> Maybe now is a good time to step back and consider what kind of programming job you might want to target.
This is definitely something you should keep in mind. Try to become really awesome at one thing. That's not to say you shouldn't have a well rounded education in programming, just that someone who is simply ok at everything isn't getting a job anywhere.
Here are a few texts which I consider to be great for a novice programmer:
The C Programming Language : ANSI C
It's an older book, but it's still the best book to learn the language.
C++ Primer : C++
I used this book to get started with C++, and found it to be easy to follow and informative. Some say it's not a beginner book per-se, they may be right. I was already very familiar with C when I started.
Objective-C Programming: The Big Nerd Ranch Guide : Objective-C
If you're planning to write apps for Apple's iOS and OS X platforms, you're definitely going to need to learn this. Otherwise, don't bother.
Algorithms : Algorithms / Data Structures
This is not the be and end all authority on algorithms, but it's a great book. It's less theoretical and more concrete in my opinion.
I don't feel qualified to give recommendations for other topics like Java or web development, as those aren't really my strong suits. Happy hunting!
If you can get another book, I would recommend this one; it is basically written to be the other book's only prerequisite, so it will take you through the language without assuming that you already know anything at all. As far as Internet tutorials, the first thing I found in a quick search that makes similarly few assumptions is this. There may be others, I'll try to look more later.
Keep in mind also that, if you want to write iOS applications, you're going to need either a Mac or some kind of hackintosh, because the tools you will need run only on Mac OS.
This book by Aaron Hillegass is what I consider to be the bible for noobs. He's an amazing teacher.
Objective-C Programming: The Big Nerd Ranch Guide
I've been writing Objective-C for a decade now and writing iPhone apps since Apple first launched their SDK, and since wayyy back in the Mac-only days I've always referred people to "the Hillegass book".
I'm considering starting off with this and then moving onto this book
I'm currently working through the Big Nerd Ranch books which are fantastic. They have such a good way of teaching - you are constantly writing code and there are a lot of challenges for you to complete at the end of chapters. I picked them up after recommendations from many other redditors.
They have two books:
I started with the first and would definitely recommend both.
Before you read any iPhone-specific development books, you're going to want a good understanding of the C and Objective-C language. Trust me, building a good foundation will help you immensely down the road. I can't recommend this book highly enough. http://amzn.com/0321706285
if you could save up for C++ Primer, its really a good book on C++, I can't recommend it enough.
But for the 15 euro price range, perhaps the A Tour of C++ a book written by the language creator himself.
I'm not sure the order they'll teach the courses, but from what I've seen generally, in computer/software engineering streams you start with C++. The book I'd recommend would be this one. It's a great book that goes into real depth. In my opinion, once you learn C++ well, you will breeze through Python, Java and C#. Although, you will most likely be using a different book for your course.
As far as laptops, it seems you've decided on Macbook Pro. One thing I'd check is what your school recommends. At one of the universities I attended they used software that was specific to Windows only; most students had Macs so they struggled. Although, you can technically use a VM.
You'd have to forget nearly everything you know about Java. Most of the stuff doesn't apply (outside of some similarities with the class syntax). Programming Java style in C++ is one of the biggest mistakes people make when learning C++ from a Java background. My only strong recommendation is to avoid that mistake and realise that just because C++ has classes does not mean that the ways to do things in Java are the correct way to do things in C++.
With that out of the way, the best resource I can recommend would be a good book. I recommend C++ Primer as a good book to learn from. There are, unfortunately, not many resources teaching C++11 as it is relatively new but C++ Primer does a pretty good job.
It is, but you want this one instead.
The gold standard in beginner C++ seems to be Lippman, Lajoie, and Moo's C++ Primer, and at < $40 USD on Amazon, why not just pay the money? It is a good book, and if you are serious about learning it, that is a great way to go about it. Plus the money spent might owrk as a little more incentive to actually do it.
I don't know about any good video tutorials, and haven't thought about the medium enough to comment on it. I don't do well with them, and in my experience, they tend not to have a lot of exercises, which will help make you a good programmer.
Hi, thank you. :)
You should learn C++ using C++ Primer by S. Lippman. (Not to be confused with C++ Primer Plus which was linked here before). Just be sure to learn modern C++, not "C with classes"! Then I recommend reading Effective C++ and Effective Modern C++ by Scott Meyers. Effective Modern C++ has some awesome examples of modern C++, but it also contains pretty hard edge-cases, so be aware of that.
The best way to learn Lua is by this book. It's very well written and I consider it to be not only the best book about Lua, but one of the best programming books ever!
Lua Users wiki is also very useful and contains lots of resources and sample code.
I also recommend checking out SFML Game Development book which is well written and contains some game programming patterns. You'll find it very useful even if you don't use SFML.
Oh, and Game Programming Patterns is a great read too.
___
Now, how much experience should you have with C++ to make games with it? That's a hard question! You should just start learning it and try making some small games with SFML or Corona. You'll see what you have to learn for yourself. :)
This book: https://www.amazon.co.uk/C-Primer-Stanley-B-Lippman/dp/0321714113
Don't bother learning C++ from online resources.
To learn C++ as someone completely new i recommend this series on youtube: https://www.youtube.com/playlist?list=PLAE85DE8440AA6B83
This will introduce you to the language and alot of the concepts that carry over to other languages as well. After you go through that whole series as boring as it may sound i really recommend you buy a textbook and read through it, doing whatever programming projects / exercises that interest you. My recommendation for a textbook would be C++ primer:
https://www.amazon.com/Primer-5th-Stanley-B-Lippman/dp/0321714113
Edit: Also, I would recommend as your first language you start with Python. Its becoming more and more popular as an introductory language and its well suited to get you past the initial learning curve. I personally haven't worked with the language too much myself so I cant provide you with any recommendations. Good luck, comp sci is an incredibly interesting subject and is useful in so many aspects of work. :)
The C++ Programming Language is a good reference. If you want something more beginner friendly, C++ Primer is good.
The C++ Programming Language (4th edition) by Bjorne Stroustrup is the de-facto C++ reference and understanding book. Hands down. Take a quick tour in earlier chapters and in depth references later in the book. If you’re an experienced programmer, it should start making sense to you pretty soon.
If you want another practical and feature-driven C++11 book then C++ Primer (5th Edition) https://www.amazon.com/dp/0321714113/ref=cm_sw_r_cp_api_17Luzb7M0HRNV should do it.
There's a few resources. Ultimately it comes down to you sitting down and playing around with all this stuff. Sure you can watch courses, read books, etc but the best learning experience comes from using the programming languages, operating systems, setting up the server emulators, etc.
Keep in mind that you won't learn everything overnight. I started my time with all of it back in 2005. Wasn't until around 2009 that I had a firm grasp of most of these concepts and turned it into an actual career path. These are all skills that can be used outside of RO stuff.
First off I messed with a lot of languages before I think I really grasped the basics. I'll note that I used some Qbasic and Lua before starting my CS degree but I don't think they taught me good fundamentals because they are a little more "simple" and left me confused looking at lower level languages which is pretty much anything else.
I just started my CS degree recently and finished the first class which was in C#. I felt like this language really gave me a better grasp on the fundamentals.
More importantly than the language though I'd say get yourself a good book. For my C# class we used this book which is really good but kind of expensive. If you are interested in C++ many people recommend C++ Primer or The C++ Programming Language.
In taking my C# class I realized I thought I knew a lot about the basics of programming but actually didn't fully understand some very basic stuff, even things I had used a lot before.
You want this book https://www.amazon.com/Primer-5th-Stanley-B-Lippman/dp/0321714113
C# has excellent tutorials on the official Help site for Visual Studio 2013. You can download Visual Studio Community for free here. It is fully-featured and allowed for personal use (both non-commercial and commercial); you just are not allowed to use it on a development team of more than 5 people. After you become experienced with C#, learning Java is as easy as going through a textbook (also available in a physical version) and/or study guide (the latter might be a little too toy-ish for you if you're looking for job skills). If you are opposed to C# due to not liking Microsoft etc, then I'd use the previously linked Sedgewick and Wayne book and download Eclipse. Fair warning, C#'s tutorials are excellent and I've never found a better way to learn to code using a language with significant real-world use... if you choose the Java route to begin with it may be hard if you're not using a formal class. Once you know how to program, I'd say going through the MIT OpenCourseWare Intro to CS class would be a good idea to learn a different kind of language (Python, which has more scripting elements to it). C++ would make a good language to learn third, the best resources I've found so far for that are here, the book can be found as a PDF here or as a physical version here... warning, not all the material is available at all times due to the fact that it's an actively running class. A class on algorithms (book here, you may need to learn more math... probability, calculus, set theory, and the like... first, not sure what your background is on that) would be a logical step to take somewhere down the line. After that you will pretty much have most of the skills that someone with a minor in CS would get, learning the HTML/CSS/PHP chain and building a website would be a good way to round out your skill set. You should be able to get through quite a bit of this in the next 18 months. Good luck! Also, as others have said, try not to spend too much money... most of what you need can be found on the Internet, and the rest should only be a hundred dollars or so for a textbook. If another topic in CS that I haven't mentioned interests you as well, there's probably an OCW course for it, the sky is the limit once you have a firm foundation (I'd say the bare minimum for that is knowing Java and C++ and thoroughly understanding the material in the Algorithms class I linked above... still I've found C# is far easier as a first language though so if you try to shortcut it you might struggle... once you know one language the rest come pretty easily, especially if they are as similar to your first as C# and Java are, so your first goal is to learn C# [or Java if you are still that adamant]).
Get a book and an idea what you want to do, the C++ Primer comes highly recommended, but it's only going to tell you how the language itself works.
Also, check out the FAQ from the sidebar.
Read books. It might be boring, but a lot more informational than watching a youtube video.
If you already know how to program in another (preferably OOP) language there's The C++ Programming Language or C++ Primer if you want to learn C++11 (not to be confused with C++ Primer Plus, which is a different book 'series')
If you don't know how to program and you want to learn C++ for game development there's Beginning C++ Game Programming, which starts at the beginning (variables are one of the first things explained). After that book you should read up Introduction to Algorithms to make sure you're not writing horrible inefficient programs. Then there's Design Patterns: Elements of Reusable Object-Oriented Software to teach you more about certain patterns used in programs design (needed when using Ogre3D for example. Ogre3D was 90% magic to me until I read about Design Patterns. :p As alternative to DP:EoROOS there's Head First Design Patterns, but it's Java-centric which is a whole other beast than C++.
After those books there's this Stackoverflow thread. Read the first answer (the gigantic list of books). The thread used to be a ton of comments (with the most votes comments on top), but all anwers got copied to the first comment, so it's all sorted on votes. Code Complete (2nd edition) was the most upvoted one, The Pragmatic Programmer was the 2nd most upvoted one, etc.
Then there's this Stackoverflow thread, which is more C++ centric.
I hope this helps :)
> I'm really only showing them the deep end
Fair enough.
> const correctness has less functional impact on what a program does than functions/arrays/pointers/OOP/many-other-concepts
True, it doesn't affect the behavior of the code. But code that works is not inherently good code. It's hard to write good code in C++ and I see a lot of bad C++ come through r/learnprogramming so I am of the opinion that best practices should be taught early. I can understand your argument with opportunity cost though.
Perhaps it's sufficient to say at the outset "if you don't expect something to change, mark it const; I'll explain further in the future". Then in your lectures you can mention it in passing, e.g. "This function should not modify this parameter so I am making it const". It's easier to remove a too-restrictive const than it is to insert a necessary one later. You can expose them to consistently good const usage before you explain in detail.
> I may ask for your feedback on that lecture specifically when I do it, if you're willing to participate.
Absolutely. Just let me know when.
> Movie editing is the problem
Oh, sorry; I misunderstood. Lightworks seems to be the best free editor comparable to Premiere.
> Any suggestions for good resources
In my opinion, C++ is always best learned from a book. The two that I would recommend right now are C++ Primer 5th ed and The C++ Standard Library 2nd ed. Though you will be able to skip around to the C++11 parts, both would also be good for your students.
For learning C++, personally I don't think youtube tutorials is the way. To this dayh I haven't seen any good beginner C++ tutorials on youtube that don't teach bad practices or have other notable flaws. Instead, in my opinion the best information available on C++ are various books. Since you aren't completely new to programming, I'd recommend C++ Primer 5th Edition, and for clarity, if you find a book called C++ Primer 5th Edition Plus it's the wrong one, and usually considered inferior to C++ Primer 5th Edition.
Visual studio in itself isn't a very complex thing to learn to use. You don't really need to spend a lot of time on trying to learn it to begin with, at least. You might want to check out some of their more advanced features when you've actually started to become more advanced in C++ though.
https://www.amazon.com/Primer-5th-Stanley-B-Lippman/dp/0321714113
This book is incredible. I picked it up at Barnes and Noble a few years back and it's fast paced but easy to understand. I highly recommend it if you're learning C++
http://www.amazon.com/Primer-5th-Edition-Stanley-Lippman/dp/0321714113/ref=sr_1_1?ie=UTF8&amp;qid=1342027270&amp;sr=8-1&amp;keywords=c%2B%2B+primer
Doesn't come out until August 20th but from what I understand the C++ primer books are second to none.
All about C++: http://www.amazon.com/Primer-5th-Edition-Stanley-Lippman/dp/0321714113
I heard good things about this book. It's awfully expensive, but I'm sure you could find a free copy somewhere.
https://www.amazon.ca/Primer-5th-Stanley-B-Lippman/dp/0321714113
Other than that, I understand how you feel. Learning programming for the first time can be a bit rough. For now, go through a book like the C++ Primer (or a similar one) and try to understand at least the basic syntax and key aspects of programming. (object oriented programming can come a little bit later!)
I also highly suggest, actually typing out a variety of C++ code related to a concept you're interested in, that is not straight from the textbook, then compiling and running it. For example, make an array of ints, then an array of doubles. Or write a function that multiplies two argument values and returns a double, then write a function that returns void, but also multiplies two argument values and instead prints the output. Or write a program that does a combination of things like loops, calling functions, iterating over an array. It doesn't have to be anything amazing.
It's a book/pdf. It's available for free with a little searching but I am on my phone so I'm just going to throw the amazon link your way so you can at least see what it is, who the author is etc...
https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
Thanks, but this is one 7.5 hour course and does not seem anywhere near a complete path to being job ready.
I have a Udemy account and would buy Mosh's courses on Udemy if I thought that they would form a concise package when put together. I would supplement this learning with books if necessary - specifically the following:
https://www.amazon.co.uk/dp/0735619670/?coliid=I3G8SYORH393ZR&amp;colid=1IRAIWB2MBRLH&amp;psc=0&amp;ref_=lv_ov_lig_dp_it
https://www.amazon.co.uk/dp/0132350882/?coliid=I1ZCBXMO9SV7S2&amp;colid=1IRAIWB2MBRLH&amp;psc=0&amp;ref_=lv_ov_lig_dp_it
https://www.amazon.co.uk/dp/0984782850/?coliid=I1OZDYM4OMN8N7&amp;colid=1IRAIWB2MBRLH&amp;psc=0&amp;ref_=lv_ov_lig_dp_it
But a course where everything fits together (such as a bootcamp I can't afford) is really what I'm looking for.
I recommend reading Clean Code if you haven't already.
https://www.amazon.com/dp/0132350882/
Otherwise you need to be more specific about the question and how you solved it.
Clean Code
Systems Performance
I would recommend the Continuous Delivery book (https://continuousdelivery.com/) as a starting guide for what you need to do on the CI/CD front.
It doesn’t go extensively into testing, which is basically your safety net. The Clean Code book (https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882) is a good start here.
On the whole Agile Software Development methodologies front, it’s important to understand some principles behind each framework. I’ve found this book useful on that regard: https://www.amazon.com/Agile-Good-Hype-Bertrand-Meyer/dp/3319051547
I know this might sound overwhelming, but so is what you’re describing... : ))
Reading books is an investment that will pay off on this journey you are setting on.
Good luck!
Ah, a fellow craftsman of code.
Have you read Clean Code? That book changed my life, and it interestingly suggests that often, comments aren't actually a good idea. There are exceptions.
http://www.amazon.ca/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
Consider looking into it.
I haven't actually finished reading it, but I read a good deal of it.
Most places really do have coding standards. Some will also use standards from other companies as a basis, such as Google. If you want a deeper discussion on that, Clean Code will offer a good one.
Well, I'd go with Clean Code by Robert C. Martin.
https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882/ref=sr_1_1?ie=UTF8&amp;qid=1481615168&amp;sr=8-1&amp;keywords=clean+code
Best programming book so far. At least one idea per page.
Two ideas: first is on crafting code; the second, on fullstack.
Input from programming legends on practices for writing clean code, including evolving code and code smells as indicators that things are not right in the code.
Clean Code: A Handbook of Agile Software Craftsmanship
This nonsense book gets right into initial decisions, sample application features, and architecture diagrams. Clarity is a good thing (measure twice and cut once). Developing on AWS is awesome and you are entitled to a free account for one year while learning AWS: AWS Free Tier.
Full-Stack JavaScript Development: Develop, Test and Deploy with MongoDB, Express, Angular and Node on AWS
(sp and added info)
http://www.amazon.co.uk/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
http://www.amazon.co.uk/Cracking-Coding-Interview-6th-Programming/dp/0984782850/ref=sr_1_1?s=books&amp;ie=UTF8&amp;qid=1452714513&amp;sr=1-1&amp;keywords=cracking+the+coding+interview
http://www.amazon.co.uk/Introduction-Algorithms-T-Cormen/dp/0262533057/ref=pd_sim_14_2?ie=UTF8&amp;dpID=41IHvtO0IxL&amp;dpSrc=sims&amp;preST=_AC_UL160_SR142%2C160_&amp;refRID=1FYKB42A12RXEDF1ZF1V
Pleas read this book. It will help you to write better code without so many lines.
Thank you. Working my way through "Clean Code" by Robert Martin (https://www.amazon.com/dp/0132350882/ref=cm_sw_r_cp_api_HcgKzbF6T27B1)
That book will be next on my list to read.
this book
https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882/ref=sr_1_1?ie=UTF8&amp;qid=1504297079&amp;sr=8-1&amp;keywords=clean+code
and this good free course
https://www.udemy.com/java-tutorial/
would be all you need
It can also help immensely to help future you, as well as others, if you create clear, concise variable names as well as stick to a strict set of naming conventions when you are crafting programs that may need to be tweaked months, or years down the line. I'm sure this seems obvious to a coder at your level, but so many people seem to overlook this important fact.
It bothers me greatly when I think back to some of the classes that I was taking in college (only a few years ago), where we were encouraged to use variable names like "x" or "string1".
Edit: If you haven't read it already, I would recommend checking out Clean code by Robert C. Martin; I found it to be a pretty fun read with some accurate, real life examples.
[ben non banane] (https://www.amazon.fr/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882)
Some books I enjoyed:
The Algorithm Design Manual by Steve S. Skiena, $61.15
Real Time Rendering, 3rd. Edition by Tomas Akenine-Moller, Eric Haines, Natty Hoffman, $71.20
Structure and Interpretation of Computer Programs, by Hal Abelson's, Jerry Sussman and Julie Sussman, Free
Clean Code by Robert C. Martin, $37.85
No, I just focus on writing code that you can understand without comments. Comments are redundant, prone to being out of date, difficult to manage when picked up by somebody else, and clutter code. If you can't understand a method in 5 seconds without comments, then you should almost certainly refactor that method. This is an industry standard:
http://en.wikipedia.org/wiki/Self-documenting
http://stackoverflow.com/questions/209015/what-is-self-documenting-code-and-can-it-replace-well-documented-code
http://www.amazon.com/dp/0132350882/?tag=stackoverfl08-20
http://programmers.stackexchange.com/questions/51307/self-documenting-code-vs-commented-code
http://codeutopia.net/blog/2014/12/01/how-to-make-your-code-self-documenting/
https://www.youtube.com/watch?v=QcN_Hmh88mA
http://en.wikipedia.org/wiki/Test-driven_development
Comments cause lots of problems. That's not to say comments are always bad, but heavily commented code is more suitable to small projects where you need a quick throughput rather than large maintainable software projects.
This is it correct?
"Clean Code: A Handbook of Agile Software Craftsmanship" is a good reading to improve ur programming skills to organize ur code and make it more readable.
This book adds more levels to my programming skills!
https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
Okay, so this is a very popular book for mainly OO design prinicples:
http://www.amazon.com/First-Design-Patterns-Elisabeth-Freeman/dp/0596007124
http://eloquentjavascript.net/
Also very popular, though Javascript inherently uses a lot of functional programming that might be confusing if your language of choice doesn't make use of first class functions.
http://www.youtube.com/user/derekbanas?feature=
That guy ^ goes over like every design principle you can imagine.
I've also heard that this is great:
http://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
If you check nulls all the time you're doing something wrong. Only when interfacing with third parties (through an API) should you be afraid of nulls. If you null check in your own internal methods, you are in essence saying that you don't trust your future self to use the method correctly. I see that type of coding a lot from programmers who come fresh out of college.
edit 1: If you want to read more about it: https://stackoverflow.com/a/271874
> This to me sounds like a reasonably common problem that junior to intermediate developers tend to face at some point: they either don't know or don't trust the contracts they are participating in and defensively overcheck for nulls. Additionally, when writing their own code, they tend to rely on returning nulls to indicate something thus requiring the caller to check for nulls.
edit 2: Not really a surprise that this was an unpopular opinion with the general reddit demographic being so young. I really recommend just reading the link I provided. It goes into more details about what it means to have a "contract" in programming. Also this one might be of interest. You should not have to double check all of your variables all the time. It will make your code unreadable and unmaintainable. The concept is backed by the leading code developers of the world, you don't need to take my word for it. Robert Martin writer of Clean Code:
Don't Return Nulls
------------------
https://i.imgur.com/0lKknlo.png
Don't Pass Nulls
-----------------------
https://i.imgur.com/RgCNbiN.png
Automate the Boring Stuff with Python Is also something you might want to look into. It is a little bit easier than "Python the Hard Way" in my opinion but reading both at the same time is completely doable.
Edit (added this after a bit of thinking):
For CS in general there are a couple of answers, the first is sadly to give up on reading coding literature on the kindle. Most books will make the code unreadable. But that doesn't mean that there aren't things to read related to programming. My first suggestion would be The clean Coder.
But if you are willing to remove yourself from the kindle I have two more suggestions.
First "The Art of Computer Programming" is the extreme answer. It consists of several books and I have tried going trough it multiple times without success. But each time I open the any of the books in the series I learn something new. But the books should come with big warning, these are not easy to read.
Second I would go trough the CS50 course on edX.com, simply put it's the best introduction to CS available, and it is can be accessed for free.
The Clean Coder is pretty great as it talks about being a professional developer and all that that entails. Very opinionated though (as all of Uncle Bob's books are). "If you don't do TDD, fuck you" is a fairly accurate paraphrasing of one chapter. Still, I found a lot of value there.
I recently read Rework which is a very quick read, but very dense with information on how Basecamp runs their business and many ideas of things that you should or should not do. If you do any freelancing or are thinking of starting your own business at some point, I'd recommend it.
Probably going to read Remote next as I'm working with remote business partners myself.
You should really read this book https://www.amazon.com.br/Clean-Coder-Conduct-Professional-Programmers/dp/0137081073
For php
In the beginning I looked at the Larry Ullman books. Usually available on eBay if you want to keep the cost down or if you don't mind stepping close to the line from here or here
For HTML, CSS and JavaScript I used Jon Duckett HTML and CSS
amazon link to pair of books
https://www.amazon.com/Web-Design-HTML-JavaScript-jQuery/dp/1118907442/ref=sr_1_1?ie=UTF8&amp;qid=1506685859&amp;sr=8-1&amp;keywords=jon+duckett
I got this and I really enjoy it. It's pretty interactive. Just download the examples from the site and follow the book.
Jon Duckett has two books often sold as a set: one for HTML & CSS, the other for JavaScript and jQuery.
When I was an absolute beginner, they were my favorite go-to references. I still keep them at my desk.
Edit: I realize you said B&N for gift cards, but this is the Amazon link for reference
http://www.youtube.com/watch?v=iCUV3iv9xOs&amp;feature=list_related&amp;playnext=1&amp;list=SP442FA2C127377F07
Followed by http://www.amazon.com/dp/143022925X/
When you're beginning in PHP, remember that the code that you write at first will be almost surely very insecure in some way or another. Now no-one is perfect at security, but just keep this in the back of your mind while you're learning :)
PHP Objects, Patterns and Practice - Expert's Voice in Open Source -
I am only on page 65 and I got a good grasped of OOP.
Building PHP Applications with Symfony, CakePHP, and Zend Framework
Another great book. Especially if you havent decided which framework to go with.
The book Learning PHP, MySQL, JavaScript, CSS & HTML5 was one of the most useful PHP books I read as a newcomer to PHP. It's very basic but it teaches how you can start using PHP to do useful and interesting things.
After making it though that book, I think PHP Objects, Patterns, and Practice is a really good next step. It will help you learn to design, organize, and write your code to a more professional standard. It will also help you better understand the workings of a PHP framework.
For someone so spread out, one of the best things you can do is get a book about design patters / principles, as those theories spread across multiple languages.
General : http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612/ref=sr_1_1?s=books&amp;ie=UTF8&amp;qid=1345469375&amp;sr=1-1&amp;keywords=design+patterns
This was a decent one for PHP: http://www.amazon.com/Objects-Patterns-Practice-Experts-Source/dp/143022925X/ref=sr_1_1?ie=UTF8&amp;qid=1345469244&amp;sr=8-1&amp;keywords=php+design+patterns
read this
then this
Build something you like while reading them.
You should read this: http://www.amazon.com/Objects-Patterns-Practice-Experts-Source/dp/143022925X
This helped me a lot when getting used to OOP and how to practically use it in my apps.
My advice, this one: http://www.amazon.co.uk/gp/product/143022925X/ref=oss_product
I highly recommend this book: https://www.amazon.com/Basics-Hacking-Penetration-Testing-Second/dp/0124116442/ref=sr_1_1?ie=UTF8&amp;qid=1483836318&amp;sr=8-1&amp;keywords=basics+of+hacking
this explains all the steps and concepts you need for penetration testing. It's beginner friendly and pretty much explains all the phases you need to penetrate a system
after that read this: https://www.amazon.com/Hacker-Playbook-Practical-Penetration-Testing/dp/1512214566/ref=sr_1_1?ie=UTF8&amp;qid=1483836492&amp;sr=8-1&amp;keywords=the+hackers+playbook+2
Sorry this has taken me so long to get too. Been busy.
First, understand that Kali is nothing mote than a collection of tools. Its those tools that you are actually wanting to learn.
KaliTutorials is one place you can start.
Also, there is an abundance of videos on YouTube and if you are serious about wanting to learn penetration testing/security makes sure you book mark Irongeek
Like I said earlier, by the time books are written, edited, and published, they can often be out of date.
If you do want to understand some of the basics, here are books you should look at:
Metasploit: The Penetration Tester's Guide
rtfm
btfm
Basic Security Testing with Kali Linux 2 I havent read this one but I have heard good things
The Hacker Playbook
[The Hacker Playbook 2] (https://www.amazon.com/Hacker-Playbook-Practical-Penetration-Testing/dp/1512214566/ref=pd_sim_14_4?_encoding=UTF8&amp;pd_rd_i=1512214566&amp;pd_rd_r=2HDYK8BDM5MR8PV03JG8&amp;pd_rd_w=kiAl7&amp;pd_rd_wg=fAjYi&amp;psc=1&amp;refRID=2HDYK8BDM5MR8PV03JG8)
Also a good list of resources can be found here: cybrary.it
Hacking: The art of exploitation
The Web Application Hackers Handbook
The Tangled Web: A Guide To Securing modern Web Applications
The Hacker Playbook 2
The Hacker playbook 3
Black Hat Python: Python Programming for Hackers and Pentesters
I've been working with the Hacker Playbook Ver 2. It's pretty good. Has helped me learn a lot.
Install your virtual lab and follow this book https://www.amazon.com/Hacker-Playbook-Practical-Penetration-Testing/dp/1512214566/ref=pd_lpo_sbs_14_img_0/143-9151008-9706324?_encoding=UTF8&amp;psc=1&amp;refRID=7Q3QARJ97T6ZRAVDF54H
A pretty recent general purpose hacking book is The Hacker Playbook 2, from June 2015.
The Pragmatic Programmer
Clean Code
Introduction to Algorithms
Sure thing. It is called Clean Code: A Handbook of Agile Software Craftsmanship
Possibly one or both of Bob Martin's books.
Agile Software Development, Principles, Patterns, and Practices (comes as a Java or C# version, but many of the ideas will probably be useful if you are using an OO language) or
Clean Code
You mentioned some issues that sound like code cleanliness and structural issues. Getting better at algorithms really comes down to practice and exposure, there's no shortcut to this. But there's no reason to suffer from bad coding practices if there's room to improve.
A few books come to mind, which may seem like they're coming from left field, and may not seem immediately useful to the task of solving algorithm puzzles, but might be useful in the long term for you to learn how to write correct, clean code and reduce uncertainty:
EDIT: One other thing is to make sure you understand the limitations of how computers represent numbers. The need for this understanding will become clear very quickly on, say, Project Euler problems. Look into bits, values, integers, signed vs unsigned, IEEE754 floating point.
And one other thing is that it's easy to compare your solutions against some of the best solutions that exist for those problems and think you're doing a bad job when in fact you're doing an alright job if you manage to solve the problems with decent runtimes. Mind your 80/20 rule here. The extra time it probably took those people to craft those solutions is not 0, which includes whatever time they spent over the years becoming an expert at that language, etc.
Before you look into trying to optimize your code, beyond the basics anyway, I think it's more important to learn how to write readable and maintainable code first. Code that is easier to change, maintain, and write, is much much better than code that runs slightly faster.
Two books that are highly recommended for this are Code Complete and Clean Code.
Depending on how skilled you are at Java:
Then for Android specifically:
Read this
http://www.amazon.com/Absolute-Java-International-Walter-Savitch-ebook/dp/B007O10JCW/ref=sr_1_1?ie=UTF8&amp;qid=1411539417&amp;sr=8-1&amp;keywords=absolute+java
then this
http://www.amazon.com/Effective-Java-Edition-Joshua-Bloch/dp/0321356683/ref=sr_1_1?ie=UTF8&amp;qid=1411539430&amp;sr=8-1&amp;keywords=effective+java
then this
http://www.amazon.com/Android-Programming-Ranch-Guide-Guides/dp/0321804333/ref=sr_1_1?ie=UTF8&amp;qid=1411539470&amp;sr=8-1&amp;keywords=android+ranch+guide
and lastly this
http://www.amazon.com/Professional-Android-Application-Development-Meier/dp/1502311135/ref=sr_1_6?ie=UTF8&amp;qid=1411539494&amp;sr=8-6&amp;keywords=professional+android
I'm looking for something similar - not so much a 'learn ruby' book as a more technical 'best practices' type of book - something more in line with Effective Java or the Effective C++ series.
If static were an evil modifier, I'm pretty confident it wouldn't have been added to the language.
> no.
Static constant values allow the compiler to compute anything solely dependent on them at compile time, instead of at run time. Like say for example:
public static final double E_TOTEN = Math.pow(Math.E, 10);
> So singleton instead of static is somehow magically ok now? It's the same damn thing @@
Would you prefer if I used the word enum?
> I have no idea what your example is demonstrating.
It wasn't an example, it was a question. Which one provides better encapsulation? A method that has access to every member variable in the class, when the necessary values are provided through public accessor methods, or a static method that uses the public accessor methods.
If you're really serious about coding in Java, I recommend you check out Josh Bloch's Effective Java.
Do you not have the course textbook? Does it not explain well? If not, I suggest two other books instead of something online:
Program Development in Java
Effective Java, 2nd Ed
Both available for Kindle reader, so you can download and start reading immediately no matter what platform you use.
Books > blogs or reddit posts for explaining broad questions like this.
Depends on your experience. If you haven't programmed before, I think Big Java would be a good book to start with (it's the book MIT's Civil Engineering Dept uses to get them up to speed with Java). If you've programmed before, you're better off doing the official java tutorials followed by Core Java 1 and Core Java 2.
Regardless of the path you take, if you intend to do ANY kind of "serious" java programming, Effective Java is a must-read.
Finally, you'll want a good reference book. Gosling's Java Book is the definitive one, although you might prefer a book by O'Reilly.
First of all, singleton is not really a good pattern to use; many (including myself) consider it to be an anti-pattern because it's just a synonym for global state, which generally makes programs difficult to understand and test.
There are common patterns... the most common reference would probably be https://en.wikipedia.org/wiki/Design_Patterns .
I also really strongly recommend all Java programmers to read https://www.amazon.com/Effective-Java-2nd-Joshua-Bloch/dp/0321356683
It's more Java specific and covers a lot of pitfalls in the Java language and libraries. It's a very interesting read that comes from a guy who designed a lot of the Java standard libraries and learned firsthand problems with the language.
Read a lot of books. Everything is usually available as a pdf on the internet and the ones that aren't are $10 to rent on Amazon. Here's the ones that I've read that relate to this project.
Java
Android
Programming in general
> Sometimes I believe that most books are wastes of paper, because everything relating to programming can be found online.
Although this is true, the problem with online resources is that they tend to be inconsistent. They assume different competency levels, assume familiarity with different concepts, approach problems in different methods, etc. This isn't much of an issue for a veteran programmer, but I think a solid book is great for beginners. Here are two good choices.
Tips and pointers for writing good Java code
http://www.amazon.com/Effective-Java-Edition-Joshua-Bloch/dp/0321356683
Algorithms in Java with code examples
http://www.amazon.com/Algorithms-4th-Robert-Sedgewick/dp/032157351X/ref=sr_1_1?s=books&amp;ie=UTF8&amp;qid=1416453105&amp;sr=1-1&amp;keywords=algorithms
For mobile development, check out the Big Nerd Ranch books. They contain guided projects that help you learn a variety of core features of mobile programming.
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 :)
После java можно как-раз.
По java советую Thinking in Java и Effective Java и в довесок.
If you're looking to get into programming, Java is a good starting language. It's relatively easy to pick up and does a lot of things for you that C++ doesn't. A good book to start learning with is Java Software Solutions by Lewis and Loftus. Another book for a little more theoretical and advanced learning is Effectiv Java by Joshua Bloch.
Edit: Book links
Java Software Solutions: http://www.amazon.com/gp/product/0132760770/ref=pd_lpo_k2_dp_sr_1?pf_rd_p=1535523722&amp;pf_rd_s=lpo-top-stripe-1&amp;pf_rd_t=201&amp;pf_rd_i=0321465881&amp;pf_rd_m=ATVPDKIKX0DER&amp;pf_rd_r=07GGH53RVK0D4GZY11KX
Effective Java: http://www.amazon.com/Effective-Java-Edition-Joshua-Bloch/dp/0321356683
Head First Java
Thinking in Java
Effective Java
Java Concurrency in Practice
Best $150 you'll ever spend. Read in order listed.