Best computers & technology books according to redditors
We found 39,382 Reddit comments discussing the best computers & technology books. We ranked the 9,387 resulting products by number of redditors who mentioned them. Here are the top 20.
7. Gödel, Escher, Bach: An Eternal Golden Braid
183 mentions
Godel Escher Bach An Eternal Golden Braid
I'd start with Harvard's CS50 on edx, it's the best course you'll find anywhere bar none. The instructor, Dave Malan is world class. Check out CS50, and the sub r/cs50 has a lot of like minded people like you. (Note: this course is free)
Stackoverflow is your friend where you can ask any question you have or bounce ideas off of others.
Learn Java OOP (here is an excellent course): Java MOOC
Free Code Camp for web development
Build your own operating system: NAND2TETRIS
Cave of Programming : All kinds of programming
Open Source Society University: This is a solid path for those of you who want to complete a Computer Science course on your own time, for free, with courses from the best universities in the World.
r/arduino for some embedded programming fun!
.....and of course for anything under the sun: https://www.edx.org/ & https://www.coursera.org/
For BSD: https://www.freebsd.org/
For Linux: https://www.archlinux.org/
For x86 assembly: http://opensecuritytraining.info/IntroX86.html [How far down the rabbit hole do you want to go?]
***
Edit: Wow, my first Reddit Gold!! Thank-you so much kind people!!
Edit2: Colt Steele has a good web dev course and is highly recommended to do in parallel with freecodecamp
Edit3: The MIT Challenge
is Scott Young's blog on how he completed the entire 4 year MIT Computer Science curriculum in 12 months
Edit 4: The Rails Tutorial by Michael Hartl is the Bible for learning Ruby on Rails
Edit 5: For deeper knowledge of OOP check out Sandi Metz’s POODR
Edit 4: The Bible for C Programming: K&R
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.
Code: The Hidden Language of Computer Hardware and Software.
It may be a bit more lower level than you're looking for, but it'd be a great foundation to build off of.
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
Above all, make shit. Fuck tutorials, being held by the hand just takes longer. Copy other websites relentlessly, recreate everything you see. Doing > reading
EDIT Lemme link y'all up.
Extra credit
** JavaScript not included.
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
I'm going to be brutally honest here, and I'm probably going to get down-voted, but I'm not impressed with the underlying code for the project. I don't even know where to begin.
You're obviously passionate about Javascript, but runtime engines and best practices have changed dramatically in the last few years. Some things that stick out could easily be chocked up to coding style or preference, but when those preferences aren't well-adjusted to current-day standards, it leads to a perpetuation of those bad practices and hinders the growth and evolution of web development overall.
I'm posting this here, instead of on Github, because these aren't quite bug reports. I'd be more than happy to contribute though.
Cutting corners in the interest of character count is useless. It's better to be able to read the code than to have to interpret it line-by-line.
For hinting, I recommend JSHint. It'll be nicer than JSLint, but it'll still likely hurt your feelings.
Here are some JSHint errors/warnings that popped up:
> The body of a for in should be wrapped in an if statement to filter unwanted properties from the prototype.
> Expected an identifier and instead saw 'arguments' (a reserved word).
> Expected a 'break' statement before 'case'.
A lot of syntax errors can be solved by linting or hinting, and following a style guide. Here's Google's Javascript Style Guide. You'll find that most projects on Github follow the same code conventions, and for very good reason. When you make your code consistent and readable, other developers will be more likely to like you and contribute to your projects.
I really like the project, but the code is unwieldy and confusing.
You don't need school to learn how to do that. It's true for most things in life but it is even easier with computer science.
Want to learn C ? No school will ever teach it better than the book The C Programming Language (also called K&R) by Brian Kernighan and Dennis Ritchie.
Want to learn C++ ? You should start with C or C# or Java and then go for Programming: Principles and Practice Using C++ by Bjarne Stroustrup.
Want to learn Python ? Go to python.org and pick a tutorial.
Want to learn Javascript ? Eloquent JavaScript by Marijn Haverbeke.
Want to learn HTML5 ? Maybe have a look at diveintohtml5.info or W3Schools
Want to learn Java ? The Java Programming Language by Ken Arnold or Head First Java by Kathy Sierra.
You need two things, time and will. You'd be surprise how easy it is to learn all those things if you like it and if you have a dream project.
edit: Woh, thanks for the gold. :D
When you learned Spanish, did you start having full-fledged conversations? Just walked into class on day one and boom: "tango el gato los pantalones"?
If I were a betting man, I'd say no.
They gave you a book for grammar, a dictionary for words, and taught you ways to pronounce and express sounds that aren't in English.
Most videos (whether they mean to or not) are presented in such a way, that you need to know Spanish before you start learning Spanish. Sometimes you get lucky, but most are for the already initiated.
I usually recommend this book for the uninitiated. It's quite descriptive, very short, and covers a large amount of topics briefly enough to get one interested in the language (or in programming in general). This is your grammar book.
Here's your dictionary.
The last thing you need is to use the language. In the case of programming, solve a problem. If you want to make games; learn the basics of Java grammar, and make a guess-the-number game. Then work up to a text adventure. Then figure out how to do pong, then breakout, then tetris, then Mario.
Software development isn't about knowing everything. It's about knowing what you don't know and learning what you need to learn to solve the problem.
Ditto - I have a Eastern Economy Edition of K&R when I took up learning C as a hobby. When I looked up the price for the same on the US version of Amazon, the price comparison was startling.
[Here's the US paperback version, priced at about 53 USD according to Amazon, i.e. 3,554 Indian Rupees. Of course, the cheapest one you can still get new is about USD 15 or so dollars. ] (https://www.amazon.com/Programming-Language-Brian-W-Kernighan/dp/0131103628/ref=sr_1_1?s=books&ie=UTF8&qid=1474085789&sr=1-1&keywords=kernigan+and+richie)
Here's the Indian "Eastern Economy Edition", paperback, of the same book, identical in every single respect, priced at a whopping 194 rupees, or about 3 dollars.
For the money you'd be shelling out, it'd be cheaper for you to buy a brand new copy of the book from an Indian bookstore and have it shipped out to you (possibly even through an express courier like DHL or FedEx) in the US than just buy the book in the US outright.
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.
We did something similar as well. The labs were tons of fun. I remember having to run a couple dozen lines of code through the CPU cache on a test once, including some sneakery of using code as data at one point. I do appreciate having done it, but I'm not sure how much practical lasting value that really contributed.
That said, for those who are interested in this there is The Elements of Computing Systems: Building a Modern Computer from First Principles, more commonly known as "NAND to Tetris".
Petzold's Code is excellent as well.
Edit: Actually, while I've suggested those two let me throw Computer Systems: A Programmer's Perspective into the mix. It's a book we used across two courses and I really enjoyed it. We used the 2nd edition (and I have no issue recommending people get a cheaper, used copy of that), but there is a 3rd edition now. Being a proper text book it's stupidly priced (you can get Knuth's 4 book box set for $30 more), but it's a good book.
Anyone have suggestions similar to that Computer Systems's text? I've always wanted to revisit/re-read it, but could always used a different perspective.
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.
Actually, start with some programming, then move on to "The Art of Exploitation" it's the best book on "hacking" I've ever used...
If you're really serious about learning, I HIGHLY recommend the book Code: The Hidden Language of Computer Hardware and Software. It's basically a book that 'builds' a computer from the ground up, starting with simple morse code type stuff through the wire, and each chapter just keeps building until you get to assembly and some higher level language stuff at the end. You do have to think through (or glaze over) some stuff in a few chapters, but it's a very eye opening book.
Edit: Grammar
+1, don't just circle jerk and pretend you're above learning patterns before you even understand why they exist. They can be abused, but they exist for good reasons.
I strongly recommend going over Head First Design Patterns to anyone interested.
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).
CODE by Charles Petzold is the book to read to understand computers at a base level. It literally starts at a single bit and moves all the way up the stack. I cannot recommend this book enough for someone starting out.
HTML and CSS are pretty simple, I would spend almost no time reading about them (Unless this is for some sort of job interview) for the most part you will just be googling "How to I make round borders" until you can do it by rote memorization.
JS, on the other hand, is a tricky beast. I would spend a majority of my time learning not just how to write javascript, but how to write good javascript.
javascript the good parts and Javascript garden is where I would start out learning. Javascript is easy to write, but hard to write well. You need to follow strong conventions otherwise your code will end up looking like spaghetti right quick and in a hurry. If you start playing around with the language, I would suggest using JSLint to make sure you aren't doing anything stupid.
After getting a good strong base in javascript jquery shouldn't be too hard. It is just a javascript library. perusing through the docs and getting a feeling for what it can do is probably all you really need. Just like any library you've used. You didn't learn all of the .Net framework, rather you would google and lookup specifics as you needed them. That is much the way you are likely to use jQuery. It can do a lot and you don't need to know everything it can do to use it effectively.
In short, javascript is where the traps are. The other things you mentioned are "I'm going to google this anyways" so I wouldn't really spend a large amount of time learning them.
In my opinion; every book in this bundle is a bag of shit.
Here's a list of reputable books, again in my opinion (All links are Non-Affiliate Links):
Web Hacking:
The Web Hackers Handbook (Link)
Infrastructure:
Network Security Assessment (Link)
Please Note: The examples in the book are dated (even though it's been updated to v3), but this book is the best for learning Infrastructure Testing Methodology.
General:
Hacking: The Art of Exploitation (Link)
Grey Hat Hacking (Link)
Linux:
Hacking Exposed: Linux (I don't have a link to a specific book as there are many editions / revisions for this book. Please read the reviews for the edition you want to purchase)
Metasploit:
I recommend the online course "Metaspliot Unleashed" (Link) as opposed to buying the book (Link).
Nmap:
The man pages. The book (Link) is a great reference and looks great on the bookshelf. The reality is, using Nmap is like baking a cake. There are too many variables involved in running the perfect portscan, every environment is different and as such will require tweaking to run efficiently.
Malware Analysis:
Practical Malware Analysis (Link)
The book is old, but the methodology is rock solid.
Programming / Scripting:
Python: Automate the Boring Stuff (Link)
Hope that helps.
Introduction To Algorithms is kind of the gold standard. It's heavily detailed, well written, and I'm pretty sure they put the word "Introduction" in there as a joke(it's 1292 pages).
I'd recommend figuring out who's responsible and them giving them a copy of Don't Make Me Think. It's a relatively short book, so they might actually read it, then they might actually get some good ideas.
Here's a list I compiled, the list books kind of hit a wide range. I don't really have any given list of talks I like. I'll just randomly google for videos by a speaker i like or subject I'm interested in.
Books:
Watch:
Podcasts:
Blogs:
News Letter:
Misc:
Sure :)
EDIT: Added links to Amazon just in case anyone wants to see reviews.
[$1 Or More Tier]
Head First Ruby
Head First C
Head First Object-Oriented Analysis and Design
Head First SQL
Head First Statistics
[$8 Or More Tier]
Head First Javascript Programming
Head First PMP
Head First HMTL and CSS
Head First C#
Head First Agile
[$15 Or More Tier]
Head First Design Patterns
Head First Java
Head First Python
Head First Learn to Code
Head First Android Development
My bad.
In Object Oriented Programming (OOP), there are lots of design patterns that end up getting repeated all over the place. You might have run in to the factory pattern, or perhaps the builder pattern?
If you can understand and notice these patterns, it means you can re-use old code more effectively, because code to handle a pattern in one place is probably very similar to code to handle a pattern in another.
In addition, if you're discussing a problem with somebody, it means you can refer to the patterns by name as a sort of shorthand notation for "put it together like this". Saying "use a decorator" is a lot quicker and easier than describing what exactly "a decorator" is from scratch every time.
The "Gang of Four" are four Computer Scientists who were among the first few to notice that these patterns kept popping up, and wrote a pretty well known book describing about 20 of the most common ones.
In this specific instance, the builder pattern would probably have proved useful. Rather than having a single, monolithic constructor, you create a separate "builder" class.
Character chararacter = new Character(xx, yy, life, kpph, kpyl, kvin, krak, kgr, kptgr, kbb, havepph, havepyl, havevin, haverak, haveya, isevented, x1, y1, x2, y2, x3, y3, x4, y4, x5, y5, IE)
Can become
Character character = Character.builder()
.life(life)
.initialCoordinates(x1, y1)
...
.build()
This is waaayyy more readable (especially if you're assigning values as arguments, rather than named values. If you ever called createFrom(...) with a string of numbers, it'd be very difficult to work out which number was what), and a lot easier to lay out properly. It also means you can gather arguments for creation gradually over time rather than all at once.
Also looking more closely, and as /u/PM_ME_YOUR_HIGHFIVE pointed out, they're not actually using objects at all, which would be a good place to start.
The C Programming Language (commonly known as K&R) remains the best resource for learning C.
the bookstores of American universities are independently owned/operated to the university, and in fact just license or are a reseller of materials from the university itself when it comes to branded gear.
They're known to overcharge for a lot of books. Consider that The C Programming Language costs $30 new for a copy. My university wants $50 for a used copy of an out of date printing that was based on a draft.
The professor of this class actively says "DO NOT BUY THE BOOK. I WILL PROVIDE YOU A PDF." Despite this, people still buy the book.
This semester, I bought a book for one of my classes on amazon because the bookstore was like "LOL IT'S OUT OF PRINT WE DON'T HAVE IT." This was inverse of the email (that was later claimed as "forged") from the instructor, forwarded from the bookstore, saying it was in stock. On top of that, they wanted $350 for a book that's $40 new.
Sorry to see this getting downvoted. Read the about page to get an idea of why /u/r00nk made the page.
I have to agree with one of the other comments that it is way too terse at the moment. I remember when we learnt about e.g. d-latches in school and it was a lot more magical and hard to wrap your head around at first then the page gives credit for. That and, or, and xor gates can be built up from just nand gates (the only logic gate properly explained) is also glossed over. Either go over it, or don't show the interiors of the other logic gates.
The interactive stuff is really neat. Good work on that.
Edit: If anyone reading wants to learn this stuff in more detail, two good books are
Edit, 9 hours later: Just so people don't think I'm bitching that this post is only 84% upvoted, it was struggling at below zero points and 42% upvoted when I first commented.
Clean Code
Textbooks?
Edit: I didn't realize the link was just the first chapter. If you really liked it, I do suggest purchasing it. You can find it all online for free, but I do highly recommend just having this book. It's a fun read.
 
Here's an excerpt that I really love right from the beginning of the book.
>>All programmers are optimists. Perhaps this modern sorcery especially
attracts those who believe in happy endings and fairy godmothers.
Perhaps the hundreds of nitty frustrations drive away all
but those who habitually focus on the end goal. Perhaps it is
merely that computers are young, programmers are younger, and
the young are always optimists. But however the selection process
works, the result is indisputable: "This time it will surely run," or
"I just found the last bug."
Here's a link to a Physical copy [on Amazon] (https://www.amazon.com/Mythical-Man-Month-Software-Engineering-Anniversary/dp/0201835959) if you want it.
 
edit: Bonus Dilbert Comic
Exactly this.
For quite some projects, I had to find a freelance frontender or webdesigner.
Here's how that goes:
I'ts a great way to separate the rubbish developers from the good ones. If you manage to present your information on one page, with a few clicks to learn more about a certain project, in clean, simple HTML, preferable recenly updated to work on mobile (responsive): you're through. But if you cooked up your navigation while on LSD using Suprise.js or WhittyScroll.js you're out.
Browsing 20+ sites from designers truly is a hell. So, nowadays, I simply ask them to email me the resumes.
Because I too realise that a good webdeveloper or designer is hired most of the time. And as such, won't have time to redesign his or her site after every new change of technology. I can understand if your site looks like it was from 2008, if you've been hired and busy since 2008, it's actually a good sign.
But really. Don't make me think. Ever.
Outliers: The Story of Success - by Malcolm Gladwell
The Pragmatic Programmer - By Andrew hunt
Cracking the coding interview - Gayle Laakmann McDowell
Some book recommendations:
Others that are great and related but not as "necessary" as the above three:
Unrelated to "better code" but still great:
I first heard about these when reading Godel Escher Bach back in later high school. That book was a long, difficult read, but man did it blow my brain wide open. Quines are definitely the thing that I remember most vividly (probably because it was the easiest to understand), but that book was full of awesome stuff like this.
You should totally check it out! You can get it super cheap at used book stores since it was such a successful book.
Honestly, I'd go with Windows Powershell Best Practices instead. PSIAMOL is nice, but this one focuses more heavily on ensuring you not only get the syntax, but the proper script structure, code re-usability, high performance, and just a ton of other stuff.
PSIAMOL Teaches you how to use PowerShell. WPBP teaches you how to be good at PowerShell.
Once that's done, it wouldn't hurt to check out Code Complete which had such an impact I ended up re-writing several of my larger scripts after reading it...
Code.
Code, by Charles Petzold
Here it is on Amazon.
Creo que mucha gente se confunde ser autodidacta con hacer algun cursito de como hacer una web y darle con eso.
Para llegar a cierto nivel, tenes que aprender computer science, teoria y trabajar en cosas que te permitan aplicar esa teoria.
Tenes que saber ver un algoritmo y poder calcular la complejidad, tenes que entender que son las patrones de diseño y cuando conviene aplicar tal o cual.
Tenes que entender como funciona OOP, pero tambien tenes que aprender algun lenguaje funcional, te va a hacer un programador más rico.
Tenes que entender de Unit Testing, automated testing, Integration testing.
Los dos libros que más me ayudaron cuando empecé en computer science son :
https://www.amazon.es/Algorithm-Design-Manual-Steven-Skiena/dp/1848000693
y
https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
Y ir codeando mientras vas leyendo y aplicando las cosas es fundamental.
Me parece que la diferencia entre ser autodidacta es que no tenés esa vara minima que te da la facultad, asi que depende de vos que tan crack queres ser y si estas dispuesto a poner el laburo y a aprender cosas constantemente.
La información esta en internet o Amazon, no hay ningún secreto.
I've been in a somewhat similar situation. First off, tell your boss that the deadlines aren't happening. They're trying to get all three points of the project management triangle, and it's not going to work. They need to compromise on something. While they're figuring that out, let's get to work.
Step one, if you haven't done this already, is to check everything into version control. You can't do anything about the past, but you can fix the future.
Working Effectively with Legacy Code is a well-reviewed book. Maybe you'll find it more useful than I did - ask your boss to buy it for you. My summary of it is:
You need a working test environment. The one the customer calls production is ideal (for you), but if that's not going to work, you need something as close to it as possible. It is management's job to solve this problem for you so you can do your job. Tell them that you're working with the 4-hr feedback window, and the more time they take to fix that, the longer this is going to take.
You mention that there's no documentation, and that you've read thousands of lines of code but still don't understand how it's pieced together. As you read the code, write the documentation. Be as extensive as you can. This is also a good time to write tests that verify the behavior you think is supposed to happen. And don't just read a file at a time, top to bottom - approach it always with a purpose, eg "how does this page get generated?". This will help you understand the flow, because you'll be tracing it repeatedly, so you'll start to see patterns in how it's all put together.
May the Force be with you.
This book is an amazing book I recommend for anyone who "knows how to write code" and has built a few things. It's a classic. Reading it cover to cover strengthened my coding skills considerably, and lessons I learned from it I apply to every new project I tackle.
[edit:] For example, the DRY principle: Don't Repeat Yourself. Basically, every operation and value in your code needs to be represented once. Two extremely similar functions? Do not copy and paste. Abstract the function slightly and find a way to make it do your two similar operations with the same basic function structure. This keeps your code clean and much easier to modify/maintain.
Need to do the same function in two different classes? Break the operation out into its own class or an abstract class (or other options depending on the language) and make both classes use it, because you'll probably find other similar crossovers that both classes will need. (These cases vary in practice, but you'll get a feel for it.) Hell, on a few occasions I realized after doing this that it was more practical to merge two or more classes into one giant abstract class and write smaller, specific children, and this helped tremendously.
Some situations might arise that this helps:
The bottom line is that, whatever your rationale might be, this code is extremely difficult to read and understand for anyone who isn't you. I had to just skip over the entire tokenizer because I wasn't getting anything out of trying to read it, except for frustration. The algorithm portion isn't much better.
Good names are one of the best ways for an author to communicate how their code works to other programmers. They provide the foothold that the person reading the code needs so that they can begin understanding the algorithms. With what you've got here, the reader must already understand the algorithms before ever seeing the code, so that he can map the concepts he already has in his head onto the uninformative variable names.
I'll give you an example that I paraphrased from Code Complete, which, if you haven't heard of it, is one of the absolute classic works on the topic of how to construct good code. What do you think this code fragment is doing:
a = a - b;
c = d + sales_tax(d);
a = a + late_fee(e, a) + c;
a = a + interest(e, a);
Despite the good function names, it's still extremely difficult to figure out what this code is trying to accomplish; if I have to make a change in something that relates to this module, I don't know where to start. But, after we name the variables:
balance = balance - last_payment;
monthly_total = new_purchases + sales_tax(new_purchases);
balance = balance + late_fee(customer_number, balance) + monthly_total;
balance = balance + interest(customer_number, balance);
See how much easier it is now to see that this code is computing a customer's bill based on their outstanding balance and a set of new purchases from the current month?
Using good variable names allows anyone to just read your code and understand immediately what it is doing. Without good variable names, anyone reading your code has to already know what it is doing.
This exists.
You have read our Bible, right? ;)
Cormen’s intro to Algorithms. A classic
https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844
Introduction to Algorithms (CLRS). I bought this book the year before I started university. I've now moved into my own place, and the first book I brought was that one. There's no technical other book I've read that many pages of. It's really filled with information, and presented in a rigorous, formal way.
Definitely my best purchase, books or otherwise.
The books get outdated too fast.
This should help you though.
---
Validate Your Skill Level
Are you currently a web programmer? If no, please do not attempt to become one to code your own dynamic website as security is a huge issue and it will take you years to catch up. It is not a reasonable effort to put forth if you want to keep your sanity, not burn your spare time, etc. Not saying you can't learn it, just saying it takes a lot of work and time that most entrepreneurs don't have to use and in some cases waste.
You can learn how to do html and css within a few months but using a CMS system is much cleaner and easier and if you need something dynamic, you will probably need a developer.
You generally need to know at least php and mysql for dynamic websites unless you want to get into the confusing worlds of joomla and drupal. I hear decent things about Ruby on Rails though on par with php and mysql learning curve I think.
Want to Learn Web Programming Anyway?
Try CodeCademy for interactive programming learning.
No Coding Skills Start Here
Get / Use the following:
Need Something More Dynamic?
You have a few options. This list goes from least expensive to most expensive. Just know that most things you want to do already have a plugin or theme designed for them for WordPress. There are however a lot of exceptions to that guideline and that is why you look at the following options.
The reason why WordPress is mentioned a lot is because it is a CMS aka Content Management System which allows you to manage a ton of the pages and posts and various other aspects of the website. If a developer really needs to, they can modify the core parts of WordPress. Rarely will you need someone to build you a brand new website and honestly you really do want a CMS or you are going to have a hard time.
Some developers can be found here: Elance (freelancers), Matchist (freelancers), and Glowtouch (dev company vetted by Bluehost)
Things to remember with website development
I am actually writing a series on this because this guide is way too small. You can sign up to be notified on this quick google form I threw up.
Every programmer should have this in their bookshelf: http://www.amazon.com/Introduction-Algorithms-Third-Thomas-Cormen/dp/0262033844/ref=pd_bxgy_b_img_c
As one of the people who commented on that thread, I feel the need to respond to this as rationally as humanly possible.
For starters, let's clear up the difference between fractal mathematics, fractal woo, and what Douglas Hofstadter might call fractal analogy.
>“Everything big is just like everything small!” they exclaim, “the universe is self-similar!”
...and then using such logic to thereby justify whatever silly energy-Reiki-mystical-connectedness-telepathy-de-jour they want.
As well, Chaos Theory - the study of how immensely complex patterns emerge from seemingly simple preconditions - is full of fractal mathematics. Given that the universe is absolutely packed with iterated functions and self-similarity almost everywhere we look, I think you can absolutely take the point of view that the universe is fractal in nature, especially when you are in a self-induced state where your brain makes a lot of connections you might normally overlook or not even bother to think about.
My point is that discussing things in the universe as self-similar is useful to mathematicians and non-mathematicians alike; using the word "fractal" to describe natural systems that exhibit those familiar patterns might not be perfectly correct, but it's not itself offensive or an affront to reasonable discourse. I manage a business; so what's your problem if I visualize the structure of my company as a fern leaf with departments and employees as branches off the main stem? What would be the issues of discussing how incredible human cellular morphology really is with my biologist roommate, and citing some cool research someone decided to do about fractal geometry in the way our bodies build themselves?
EDIT: OP's edit makes it more clear his statements were more about irrational folk seeing the universe as a single continuous fractal (that would be the "fractal woo"), and that he is not denying the existence of fractal-like patterns in nature, or that using fractal models can be useful in understanding phenomena. Sorry for any confusion and thanks for the discussion!
EDIT2: /u/ombortron commented pretty well in regards to the utility of the concept of fractals in scientific discourse and otherwise:
>The universe itself doesn't have to be a fractal for fractals to be important.
>Fractals are quite common in our reality, and as a result, that means they are an important facet of reality, and as such they are a legitimate and common topic of discussion amongst people, and this is particularly true of people who do psychedelics.
>Does this mean the universe is 100% fractal in nature? No.
Get your man pants on and pick up a copy of CLRS.
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
Introduction to Algorithms
Also, video lectures
Edit: these are not affiliate links :)
To get a feel for low-level computing you should learn C. All modern operating systems and low level utilities are written in C (or C++, which is C with objects). It is as close to the metal as you can get while still being useful. Maybe you could fiddle around with some assembly afterwards.
Now, as for understanding how an operating system form top to bottom works, Windows is a pretty shit place to start for the following reasons:
Instead, you should learn Linux, and learn how Linux works. Installing it in a VM is fine. If you're looking to learn, I suggest you start with Debian, and, after you get comfortable with the command line, move to Arch. Arch is great for learning, if not much else, because it makes you do most things manually, and has a pretty extensive wiki for everything you may need to know.
Resources:
A Linux tutorial for beginners: https://linuxjourney.com
A pretty decent online C tutorial (note, you should compile the programs on your own system, instead of doing their online exercises): http://www.learn-c.org
K&R2 (the "proper" way to learn C): https://www.amazon.com/dp/0131103628/ref=cm_sw_r_cp_awdb_t1_FSwNAbFDJ3FKK
Computer Systems A Programmer's Perspective, a book that might just be what you're looking for: https://www.amazon.com/Computer-Systems-Programmers-Perspective-3rd/dp/013409266X
fwiw, bare minimum working code is often a good idea if we're talking about the amount of code to do some task :)
Design patterns are most useful in that they help you start recognizing patterns in your own code, and they show you a number of common patterns which can be useful - but it's good to keep in mind that you shouldn't force a design pattern somewhere just because it's a design pattern.
Anyway, the Design Patterns book is good, and so is Head First Design Patterns.
Charles Petzold also wrote Code: The Hidden Language of Computer Hardware and Software. It's a great book. I'm sure most of the people browsing this subreddit will already understand most of what is in the book (or have read it already) but fantastic read nonetheless.
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
I think your major problem here is that you want the "why not"s instead of the "why"s. A good programmer can look at a chunk of code and determine "why" the programmer is doing certain things. These pre-extising code blocks that people refer to are given because you should be able to read through it and interpret what's going on and why. The questions you most likely ask at the "interpreting" stage isn't "why" but instead "why that way and not this way?"
Really, when it comes down to it, the answer as to that question for a lot of things in engine programming (or just programming in general) is that it's what the lead designer or lead programmer thought was the best idea.
For instance: How do you want to store your array of tiles? As integers representing tile indexes in a tile set? As separate Tile class instances in a vector array containing vector arrays of Tile instances? As a hashmap indexed using characters to grab a tile? etc. There's a million ways to handle each and every part of an engine, it all comes down to what design patterns and what theories you think are the best for what you need your engine to do.
I suggest reading up on some of the design patterns in here (actual link in the sidebar) and here. They're a great way to start understanding the multitudes of ways of handling different ideas in your engine! Reading up on pre-existing theory or seeing pre-existing pseudo-code is fine and dandy, but sometimes you have to reinvent the wheel. Sometimes, for the most part you can follow a lot of design patterns that already exist.
P.S. For a great tutorial on loading tile maps and working with them in your game, lazyfoo's got you covered (it's in C++ but can easily be adapted for other languages) Here
Excellent questions! If you are a CS grad you are ahead of the game. However, it all depends on what you want to do. I suggested learning programming/CS principles for two reasons:
If you want to find zero day exploits, yes learn how low level languages work. It would be very helpful in that case.
Otherwise, Learn python (or whatever is popular at the time) to write your own exploit tools....or to modify existing ones.
If you want to be apart of a red team learning lower level languages could make you a better exploiter. However, IMO, I would start with just learning the basics of hacking.
These two books are old but they are absolute standards for anyone starting off:
https://www.amazon.com/dp/1593271441/ref=cm_sw_r_cp_awdb_t1_GYIACb1Z2YXFA
And:
https://www.amazon.com/dp/1593275641/ref=cm_sw_r_cp_awdb_t1_zZIACbMH0WTMP
Also, learn as much as you can on how windows/Linux/virtual machines (and containers) work. The more you know about how an OS works the easier it is to exploit.
Learn to exploit, there are a ton of free sites to help you learn:
http://overthewire.org/wargames/
https://www.cybrary.it
www.vulnhub.com
http://google-gruyere.appspot.com
Learn CTF challenges:
https://ctflearn.com
When you are able to hack take part in real challenges:
https://ctf365.com
Then start your career with a RESPECTED CERT, OSCP:
https://www.offensive-security.com/information-security-certifications/oscp-offensive-security-certified-professional/
The OSCP is no joke and it is a timed, 24 hour cert test. Yes, you read that right, 24 hours.
Unless you want a government gig stay away from C|EH, it is a joke cert in the community. Again, unless you need to work for a gov agency
Finally, and I cannot stress this enough.....LEARN CLOUD COMPUTING!!! It is here to stay and on-prem systems are dying a slow death. It will change how you exploit systems and how software is engineered/deployed.
It's not a long book, but it is all about usability. It's called "Don't Make Me Think". It's informative and concise.
That Amazon Link: https://www.amazon.com/dp/0321965515/ref=cm_sw_r_cp_api_5Ohuzb82F6BEF
The Practice of System and Network Administration
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!
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/
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.
Clean Code is widely considered (at least in my circles) as a "must read" position for a pragmatic coder.
https://www.amazon.com/Head-First-Design-Patterns-Brain-Friendly/dp/0596007124
The whole subject is a bit too complicated and a bit too deep for a short ELI5, but I'll give a stab at the gist of it.
The reason why computers work (at least in the vein of your question) is very similar to the reason why we have language -- written, spoken, etc.
What you're reading right at this very moment is a complex system (language) simplified to symbols on the screen. The very fact that you can read these words and attain meaning from them means that each sentence, each word, and each letter represent a sort of code that you can understand.
If we take an apple for example, there are many other ways to say that in different languages. Manzana. Pomme. Apfel. And so on. Codes -- some symbol maps to some concept.
In the context of computers, well, they can only "understand" binary. Ones and zeros. On and off. Well, that's okay, because we can map those ones and zeros to codes that we (humans) care about. Like 101010111 could represent "apple" if we wanted it to.
So we build these physical circuits that either have power or don't (on and off) and we can abstract that to 1's (power flowing through that circuit) and 0's (no power flowing through it). This way, we can build physical chips that give us basic building blocks (basic instructions it can do) that we can leverage in order to ultimately make programs, display stuff, play sounds, etc. And the way we communicate that to the computer is via the language it can understand, binary.
In other words, in a basic sense, we can pass the processor binary, and it should be able to interpret that as a command. The length of the binary, and what it should contain can vary from chip to chip. But lets say our basic chip can do basic math. We might pass it a binary number: 0001001000110100 but it might be able to slice it up as 0001 | 0010 | 0011 | 0100 -- so the first four, 0001, might map to an "add" command. The next four, 0010, might map to a memory location that holds a number. The third group of four might be the number to add it to. The last group might be where to put it. Using variables, it might look like:
c = a + b. Where "c" is 0100, "a" is 0010, "b" is 0011, and the "+" (addition operator) is 0001.
From there, those basic instructions, we can layer abstractions. If I tell you to take out the trash, that's a pretty basic statement. If I were to detail all the steps needed to do that, it would get a lot longer -- take the lid off the can, pull the bag up, tie the bag, go to the big garbage can, open the lid, put the trash in. Right? Well, if I tell you to take out the trash, it rolls up all those sub actions needed to do the task into one simple command.
In programming, it's not all that different. We layer abstractions to a point where we can call immense functionality with relatively little code. Some of that code might control the video signal being sent to the screen. Some of that code might control the logic behind an app or a game. All of the code though, is getting turned into 1's and 0's and processed by your cpu in order to make the computer do what is asked.
If you want to learn more, I highly recommend Code by Charles Petzold for a much more in depth but still layman friendly explanation of all this.
Heres a good read to help you understand it all. https://www.amazon.com/Code-Language-Computer-Hardware-Software/dp/0735611319/ref=sr_1_1?ie=UTF8&qid=1465777171&sr=8-1&keywords=Code
I just finished reading Code: The Hidden Language of Computer Hardware and Software and will state unequivocally that this book is the most satisfying read I've experienced. It starts with flashlights blinking through windows, moves to Morse code, introduces electrical relays and demonstrates how they can be connected to form logic gates, then uses those gates to construct an ALU/counter/RAM and multiplexors. It goes on to describe the development of an assembly language and the utilization of input and output devices.
This book can be described as knowledge hose flooding the gaps in my understanding of computer hardware/software at an extremely enjoyable pace. It may help satisfy your interest in the concepts and technology that led to modern computers. Check out the reviews for more info.
If you haven't already studied logic gates in depth in your formal education, I would suggest using a logic simulator to actually build the combinational logic structures. I now feel very comfortable with logic gates and have a strong understanding of their application in computing from my time spent building the described logic.
I went through the book very slowly, rereading chapters and sections until I felt confident that I understood the content. I can not recommend this book enough.
After reading CODE, I have been working through The Elements of Computing Systems: Building a Modern Computer from First Principles. If you are looking to gain a better understanding of the functions of hardware components, this is the book to read. This book's companion site http://www.nand2tetris.org has the first chapters free along with the entire open source software suite that is used in the book's projects. You will build, in the hardware design language starting with Nand gates, each logic gate and every part of a computing system up to a modern high level language with which you can program custom software of your own design to compile in a compiler you designed into an assembly language you specified which is turned into binary that runs in a processor you built from Nand gates and flip flops. This book was very challenging before reading CODE, now I feel like I'm simply applying everything I learned in code with even more detail. For somebody that hasn't attended college for computing yet, this has been a life changing experience.
http://www.amazon.com/Code-Language-Computer-Hardware-Software/dp/0735611319
http://www.amazon.com/The-Elements-Computing-Systems-Principles/dp/0262640686
I just started reading CODE by Charles Petzold and I've really enjoyed it so far. It's an accessible take on the basics of computer science that doesn't just focus on computers themselves.
http://www.amazon.com/exec/obidos/ASIN/0735611319
Depends on what you want to do — UX is a pretty broad field. I'm a user interface designer with a UX background, which means I've designed sites, web apps and mobile apps, but there's plenty of UX positions that don't require any sort of visual design or front-end development experience.
For example, there are labs that conduct user research and interviews, run focus groups, or do user testing. Hell, you could even apply to be a user tester at a site like usertesting.com. Not sure how much money you can make from that, but it's something.
Also, there are UX positions that go from beginning research and discovery for projects up through the wireframing, which doesn't require any visual design experience. You'll usually hand off your UX work to a designer or a developer to implement.
Some good books to read about UX are:
There's also plenty of online resources about UX. Smashing Magazine has a ton of articles on it.
If you are good at puzzles, love solving complex problems, and contain any shred of empathy, user experience could be a good field for you.
I don't know how to tell you how code well, because I don't know how to do it myself. I look at John Carmack, Bjarne Stroustrup, Guido van Rossum, Herb Sutter and co. and I realize how poorly I measure. That said, I do know of some things that will certainly help you. I believe to get good at something takes time and dedication. The following is in the order that I thought of it. I'm not sure how you should attempt to learn this material. Hopefully someone else can help you out with that.
Learning how to recognize potential solutions to classes of problems and of course having the basic tools to design a solution.
Understanding the constraints of computing
There are a few exercises that I think would be helpful.
Lots of books here.
If it has to be absolutely one book, The Practice of System and Network Administration is one on how to be a well rounded sysadmin.
"Introduction to Algorithms"by Cormen et.al. Is for me the most important one.
The "Dragon" book is maybe antoher one I would recommend, although it is a little bit more practical (it's about language and compiler design basically). It will also force you to do some coding, which is good.
Concrete Mathematics by Knuth and Graham (you should know these names) is good for mathematical basics.
Modern Operating Systems by Tennenbaum is a little dated, but I guess anyone should still read it.
SICP(although married to a language) teaches very very good fundamentals.
Be aware that the stuff in the books above is independent of the language you choose (or the book chooses) to outline the material.
Get Effective Java by Josh Bloch.
I highly recommend the book Code. I read it in middle school and it was absolutely fascinating. Pretty short too.
Much of this stuff is learnable outside of work, too, at least at a superficially-passable level. Trust me.
Pick up a few seminal books and read them with vigor. That's all you need to do.
Here are some books I can personally recommend from my library:
Software Design
​
Software Industry
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.
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
I highly recommend The Practice of System and Network Administration. Goes over a whole bunch of real world tips of what you will need to be successful and keep you sane in the process. Goes over ticketing systems, time management, documentation, patching, imaging, and various other processes that are vital for any Sys Admin.
http://www.amazon.com/Practice-System-Network-Administration-Second/dp/0321492668/ref=pd_bxgy_b_text_b
You can get a degree or you can teach yourself
The above resource is pretty good in outlining the major topics that all CS programs cover, but I would change some of their textbook and class recommendations.
I would replace the programming book/course with CS for all
Algorithms I would recommend sedgewick which is also available as a website or clrs for a more in depth review.
Those two topics will give you a very solid background. For what you want to do computer architecture, networking, operating systems, math, languages and compilers, and distributed systems aren't as important. If you wanted to expand your abilities as a programmer then you should explore those topics.
As for databases, for your purposes you may not need to learn so much how databases work as opposed to how to query databases. For this you need to learn SQL.
This should give you all the background you need in CS, now its time to start building applications. You'll probably hit roadblocks and need to research how to accomplish certain tasks, but with the above background that should be very doable.
Easy. Gödel, Escher, Bach: An Eternal Golden Braid.
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
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.
Introduction to Algorithms is an absolute classic. It covers the vast majority of the algorithms that a good programmer "should" know (and goes over much of the math in the appendix in the back). Every school I've worked with has at least 1 course using this text, and typically each company doing anything interesting has at least 1 copy floating around somewhere.
I have a bunch more books that I could personally recommend if you have a specific thing you're trying to learn, but in terms of books that are 100% canon, that's the only one that comes to mind for me.
Algorithms are language agnostic but certain books are not. I recommend Introduction to Algorithms which is language agnostic and accompanied by lectures here. But there is also Algorithms by Robert Sedgewick which is in Java and accompanies these lectures and The Algorithm Design Manual which is language agnostic.
Well firstly, language is a big choice right now. If you're looking to make a financially fulfilling career in a young company or on your own, I'd recommend learning javascript to later use node.js, and learning ruby. Personally, I'm a node.js developer, so I would recommend moving toward the JS world and using really cool things like socket.io and mongoDB. Ruby is a fantastic language overall. It's a bit slow, but it does a great job regardless, and tons of really cool startups use it. At the moment, I would say that these are the two most profitable paths to take in web development.
http://codeacademy.com is a fantastic place to start. It does a great job at teaching the fundamentals of programming. If I recall correctly, the javascript courses take you from the absolute basics to building some kind of useful application, such as a calculator or todo list.
Once you've made your way through the tutorials at codeacademy, move on to http://codeschool.com. Their tutorials are a bit more advanced, and leave you with a real application and real knowledge on how to take an idea and turn it into a real product. For node magic after you've moved through Codeschool, check out http://nodeschool.io/
Here are a few books I would recommend
JAVASCRIPT
RUBY
That's a pretty interesting course. I've read the book and done exercises up until you actually have to start building the CPU.
However, I would strongly recommend reading Charles Petzold's CODE first. It's a little less technical, but explains the general concepts much better than nand2tetris.
I admire your dogged adherence to being wrong in every particular. It takes a special brand of stubborn contrarianism to quote someone's badly edited notes as a primary source and then followup by a claim that this is best possible research.
However, outside in the real world, Alan Kay writes extensively and authoritatively here and in his numerous contributions on Hacker News quite aside from publications spanning decades.
And an awful lot of people agree with his definition. The introduction of the classic Design Patterns defines objects as an encapsulated package that only responds to messages. People who teach OO programming readily quote Mr Kay's definition. The Ruby programming language is fundamentally based upon it, and before you shout "but Ruby has classes" note that Ruby classes are actually themselves objects, for which the
newmessage happens to do something particular by convention. And so on; the point being that Alan Kay's definition is super influential, which is why the idea that Erlang is the most object-oriented language is not a new proposition.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 think the two suggestions you'll see the most will be:
Code Complete
Pragmatic Programmer
Even though this seems to be just aggregating some Stack Overflow answers into blogspam, I'll bite.
> Two lines of code is too many
If you're seriously going to complain about one extra line of code in a method, I don't see this ending well.
> If it's not native, it's not really programming
Semantics. Even if you don't call it programming, you'd damn well better know those things if you want to use them. SQL, Java, and any other VM-based language may not qualify as "programming" by this definition, but they're still damn useful.
> The "while" construct should be removed from all programming languages. (In favor of "Repeat...Until")
Semantics again. There is no functional difference between the two, and I would argue that while is actually preferable since it puts the looping condition right there on the same line, instead of having to skip to the end of the block to find out if you even entered the block in the first place.
> Copy/pasting is not an anti-pattern.
No, it's not, and it's been proven. I'm having a hard time finding the peer-reviewed study on copy/paste programming right now, but basically, it's been shown to save a lot of time as long as you're using it properly.
Where the hatred for it comes in is that, like GOTO, if you use it too often, you'll probably end up using it wrong.
> Developing on .NET is not programming, it's just stitching together other people's code
A reiteration of his 2nd point, but honestly, a huge amount of working as a professional programmer -- hell, almost the definition of working in a team -- is stitching together other people's code. There's nothing wrong with that, and it's hardly controversial.
> The use of try/catch exception handling is worse than the use of simple return codes and associated common messaging structures to ferry useful error messages.
This has been getting debated a lot in go-lang circles, but the general consensus seems to be that unless you're working in an embedded environment (or some other highly-constrained environment), you're probably better off with try/catch.
> Test constantly
Test-Driven Development is something that I personally agree with, and truthfully has become a very popular practice among Rails people. I don't see how that would qualify it as being controversial.
That said, certain studies have shown evidence that TDD is not as effective as many seem to believe.
> Object Oriented Programming is absolutely the worst thing that's ever happened to the field of software engineering.
I've heard this claim semi-often. It seems to mostly come from people having worked with languages that claim to be OO but constantly make exceptions to the rules, like Java, C++, or Python. In fact, the author specifically calls out Java.
Try Smalltalk or Ruby and you'll come to see that OOP done right is actually quite wonderful.
> C (or C++) should be the first programming language
Debatable, but certainly not controversial by any stretch of the imagination.
> Classes should fit on the screen.
How big is your screen? I can fit any class definition on a 64" monitor.
Some classes simply must be large. It is an unavoidable fact that certain things are simply more complex to model than others. This point isn't controversial, it's just asinine.
> Making invisible characters syntactically significant in python was a bad idea
This again? Is it really a controversial opinion if it's been something non-Python programmers have been whining about for decades? Because as far as I can tell, people whine about it for about the first five minutes of Python coding, and then give up because they would've been indenting anyway.
It can cause bugs when transferring code between computers, I'll give them that. Otherwise, it's Python demanding good formatting, something that you should be demanding from everyone on your team anyways.
My main regret with Python is that I haven't found a good tool that auto-formats everything (a la "gofmt").
But otherwise, Python's indentation requirements are so in line with common indentation in almost every programming language that proper indentation comes naturally to more or less everyone. In how many programming languages that you regularly use do you not format your conditional, looping, class/method, or exception blocks?
> Singletons are not evil
It's not controversial to agree with Design Patterns. That book is more or less the undisputed truth on the subject, and it thinks the Singleton pattern is fine and dandy.
I’m a print and basic web designer that’s been making an overhaul towards UI/UX the past few months so maybe I can offer some help. I’m actually working on a mobile app’s case study as we speak! You may have already noticed that UI/UX tends to get many different definitions depending on who you ask. With this said the path I took was focused on research methods (competitor research, demographic research, user testing, etc), UX deliverables (personas, user flows, wireframes, etc), prototyping, high-fidelity design and front-end coding (I’ll touch on that a little more in a bit).
 
When it comes to UX research I found the following resources immensely helpful:
Books (Reading? Yes, reading. Trust me these are worth checking out…pretty short too)
Podcasts (Listen on your commute, while you’re folding laundry, whenever)
Websites (It’s also a good idea to Google some successful UX designer’s portfolios)
 
Basically what UX teaches you is that all design decisions need to be backed by an informed reason. That reason is found by doing proper research and testing.
 
Now for UI design. There’s always Bechance and Dribble for inspiration, but a lot of the pieces you find on there lack context and are merely pretty to look at. So don’t get too obsessed. For software, personally, I’m a Photoshop to Sketch convert. It’s $100 but MAN is it worth it. There’s a number of things that make Sketch attractive (vector based, easy exporting, etc) but I guess the simplest way I can put it is that Sketch just feels…lighter than Photoshop. But it’s really personal preference, if you’re a master at using Photoshop for web design then don’t feel like you have to get Sketch. With that said I HIGHLY recommend investing in Meng To’s Design+Code. While it mainly focuses on iOS design, there is a lot of information that goes across the board for UI design, and it will give you an organized learning method (plus a discount on Sketch).
 
It’s also a good idea to familiarize yourself with Material Design. Google’s presentation of the topic gets a little too in-depth at times so you may just want to Google search for other explanations of Material Design (that’s a bit ironic huh?).
 
Okay so now you know how to design a basic UI right? Well what if you want to make your designs interactive? There’s quite a bit to benefit from actually seeing your designs work (or not work). Over the past couple years there’s been a gigantic influx of prototyping programs. They all have their pros and cons. Personally I use Pixate but at times it can be a little restricting. My iOS developer friend recommends Origami, it has a pretty steep learning curve but I think I may switch to that at some point.
 
The key to becoming effective at UI design is the same with any other form of design: practice, practice, practice.
 
Okay, now on to coding:
 
Depending on your goals you may have to alter your studies a bit. For example, knowing your way around HTML/CSS and jQuery will give you more control of the design process, improve your relationship with developers on your team and make you EXTREMELY marketable. However, in many cases, only a basic knowledge of those languages I mentioned is required (jQuery being more of a bonus). As a designer you may not even touch the coding side of things at all, it really just depends on the team you’re working with. With that said I HIGHLY suggest taking a dive into front-end coding eventually, you’ll hate yourself for not learning it earlier. Ditch dreamweaver too, pickup SublimeText. Team Treehouse and CodeAcademy are fan-fucking-tastic. Learned a lot from their education programs.
 
Whew, if that seems like a lot it’s because it is. Hopefully I broke it down into digestible chunks though. Remember, design is a never-ending learning experience. Don’t stop learning.
Godel Escher and Bach is precisely what you're looking for.
Code: The Hidden Language of Computer Hardware and Software by Charles Petzold
Code Compete or maybe Code
This is my favourite:
http://www.amazon.com/JavaScript-Good-Parts-Douglas-Crockford/dp/0596517742
Head First Java is what you want.
Gödel, Escher, Bach: An Eternal Golden Braid
This book is not exactly a programming book... maybe... kinda. It teaches no practical programming language. It explains no useful design patterns. It does not deal with any practical computer applications. And yet had I never would have really gotten into programming had I not read it long ago. Written in the late 70's, it's still relevant today.
Don't give up just yet, keep looking.
Do you have a portfolio? if not try to work on a project of your own so you can have something to show.
And if you are considering improving your java skills try work with libraries like:
With spare time I would also recommend you to read:
https://www.amazon.com/Pragmatic-Programmer-Journeyman-Master/dp/020161622X/ref=nodl_
https://sites.google.com/site/steveyegge2/being-the-averagest
http://wiki.c2.com/?SoftwareDesignPatterns
https://en.m.wikipedia.org/wiki/SOLID_(object-oriented_design)
Been a developer for 18 years, never had a mentor, but these ideas/concepts I found insightful and enlightening.
This is a good start to get a taste of good code:
http://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882/ref=sr_1_1?ie=UTF8&qid=1456913184&sr=8-1&keywords=clean+code
Many developers recognize this practices and value them very much.
I'm going to start by assuming this may be maintained by another person at some point in the future. First off, naming. Although it is kinda targeted towards Java, the majority is directly applicable to C#. Clean Code. The underscores and you prefixing an abbreviation for the type should be changed. An example would be:
i_orderID
Changes to:
OrderId
because of the fact that it is a public property, and you've already told us it is an Int when you declared it. Doing this will allow others to maintain your code with less headache. https://msdn.microsoft.com/en-us/library/ms229045(v=vs.110).aspx is an MSDN article that goes over some of it.
Next, spaces in the folder names, you should avoid that for the same reason above, use PascalCase, no spaces, no hyphens, no underscores if possible.
You have no guard clauses in there. An example of adding one in would be (Line 31 'DataObjects.cs):
if (string.IsNullOrEmpty(displayLine1)) throw new ArgumentNullException("displayLine1");
Favor guard clauses over exception handling wherever possible. When you need to handle exceptions, handle them specifically. If the code you are calling can throw an InvalidOperationException, favor catching that over just Exception. Exceptions should be exceptional, not a common occurrence in your code, guard clauses help with that. Another example would be (Line 96 'Program.cs'):
if (File.Exists(s_directory + @"\Bricks.xml") { ...the rest of the code that uses that file here }
Use meaningful names. 'displayLine1' as a constructor parameter is ambiguous. Sometimes it makes sense to shorten some of the names as well; 'customerWhoPurchasedId' could just be 'customerId'.
In DataObjects.cs, you are returning '-1' as an error, I would use something more meaningful than a number. If you are going to use a number like that, use an enum so that you can read your code using friendly names, '-1' is ambiguous, but something like BrickSearchResult.Empty is not.
Style out of the way, now let's move on to data. You are a database guy. I would suggest using a database to store the data over an xml file.
Next. You are doing a ton of work in your application's main constructor. Move that code out of there, and let it initialize the app unimpeded. People debugging your code later will thank you. I would suggest using the Form_Loaded or whatever the Forms equivalent for Window_Loaded is.
On a general note, follow the principle of having each small piece of code do one thing, and one thing only. Your main class is also responsible for data access, it should not be. You should have separate classes for that, this is called 'separation of concerns'. Your CRUD operations should all be in the same class. Each class should have its own file whenever possible. So 'DataObjects.cs' would be split into 'Customer.cs' and 'Brick.cs'. Keep in mind that you can use folders in your solution as well to keep things a bit more organized.
You are welcome to PM me if you have other questions.
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
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
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.
I'm a ~10 year sysadmin that has decided to rebuild my software dev skills that I haven't used since college. Here's what I did to reawaken that part of my brain:
3.5) After going through the last chapters of C Primer Plus, I realized that some of my math skills were not up to par, so I took this MOOC from MIT to supplement that. No idea if that's something you need.
One book that helped me a lot while starting out and which I highly recommend to any new student of computer science is Code: The Hidden Language of Computer Hardware by Charles Petzold, which starts out as a general interest book about the history of computing and then very quickly ratchets up into how modern computers, compilers, operating systems, and hardware drivers are built. You basically have to learn some discrete math and assembly language just to follow along, and by the end you have a really good idea of what happens under the hood when you run your programs and why.
How deep do you want to go? Code: The Hidden Language of Computer Hardware and Software goes all the way from binary to computer code.
If you don't really care about the hardware, you might start dabbling in assembly on a Raspberry PI.
Godel Escher Bach
It's ultimately about the self-referential nature of consciousness, but it explores so many fascinating concepts that I couldn't even begin to do it justice
I would also like to take the time to plug a few resources, if I may, that have greatly assisted me throughout my career.
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!
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.
Practice of System and Network Administration
http://www.amazon.com/Practice-System-Network-Administration-Second/dp/0321492668/
Worth every cent and more.
Cormen is your friend.
Core text for the algorithms course I did as an undergrad - I highly recommend it.
Don't Make me Think A good design philosophy book. It's relatively old, but a lot of the ideas are still used today.
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.
https://www.amazon.com/Hacking-Art-Exploitation-Jon-Erickson/dp/1593271441
Automate the Boring Stuff taught me the basics and I recommend it highly. It's free.
If you encounter an error spend about an hour trying to solve it before asking for help. If you get an error with an error message from running the program you copy and paste the error message into a search engine and look for answers there. If the program behaves differently than you expect it too without giving you an error message you have probably made a mistake in your instructions to the program and these can be hard to find.
r/learnpython is great when you can't solve your problem(s), they're helpful as long as you say what you have tried, upload your code to pastebin.com and say what you want the program to do.
also when giving variables names please give them describing names. look at this example:
name = "chra94"
n = 6
name_length = 6
clearly
name_lengthdescribes itself better than justn. Many beginners me included make the mistake of naming variables poorly which makes the code harder to read. good variables makes reading the code easier.Be prepared to read documentations for both python but also tools (they're called modules or libraries) written in python for python. One day you might want to make a program that modifies or creates spreadsheets. There are libraries for that and even if you just watch a tutorial on how to use it it's easier to be able to search and read the documentation for the module than finding a tutorial specific for that one little thing you want to do that the other tutorial didn't cover.
Following the Automate the Boring Stuff book you will be able to make a rock, paper, scissors-game, making a number guessing game and such. Should you want more excercises you could look at codingbat over here at CodingBat for that.
Some day you might want to do a project. A program that's useful. Maybe it'll download the ten best wallpapers from r/wallpapers each day. Maybe you'll make a chatbot Slack or Discord or IRC. Anwyay. After having made a couple of programs that can be used over and over again by someone else than me I have realized that I have to plan much, much more ahead. My programs got messy, difficult to read, difficult to change and honestly I've lost control over them. I wish I had read Code Complete earlier. It praises planning your program thoroughly. According to some stats in the book mistakes uncovered after planning are between five to ten times more costly to fix than if they were discovered while the requirements for the program were figured out. (Theses stats are for small companies. Bigger companies can be as much as 100 times more expensive to fix.) TL;DR: Time spent planning is between three to ten times better spent than fixing stuff because you didn't bother to plan enough.
*TL;DR:** Do Automate the Boring Stuff untill you want to make stuff on your own and read chapter three of Code Complete.
Best of luck buddy and remember: Plan your projects ahead.
The dark side has lot of facets, it depends on what you want to achieve.
If you are already working on web applications and web in general, then you may want to start with the Web Application Hackers Handbook by Dafydd Stuttard and Marcus Pinto.
This is a very valid book and with your existent knowledge it will be a very interesting read: i may also advise you to read The Tangled Web by Michal Zalewski, this instead will give you a very in-depth look of browsers' quirks and their inner working, quirks you'll learn to exploit.. for science!
Then there is the world of binary reverse engineering and exploitation, my preferred literature on this is Hacking: the art of exploitation: keep in mind that the techniques there may be outdated, but the reasoning and much of the concepts are still valid. It's a very specific book with very detailed information and you are required to know a bit of assembler, C and very low-level stuff.
Happy hunting and good luck!
Read this book: Code: The Hidden Language of Computer Hardware and Software
A ground up approach to understanding digital processing and transmission in a broad sense. I only recommend this book if you are looking for an intrinsic understanding of computing rather than merely a handle on using a particular programming language or operating system. By the end of the book you should have a handle on actually building your own computer, however it's actually an excellent "first book" for anyone interested in computing.
https://www.amazon.com/Code-Language-Computer-Hardware-Software/dp/0735611319
This book is an excellent primer for a bottom-up look into how computers as machines function.
https://www.amazon.com/gp/aw/d/0123944244/ref=ya_aw_od_pi
This is my textbook from the class where we built a CPU. I greatly enjoy it, and it also starts at the bottom and works up excellently.
For OS development, I am following Philipp Opperman's excellent blog series on writing a simple OS in Rust, at http://os.phil-opp.com/
And as always Wikipedia walks and Reddit meanders fill in the gaps lol.
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
i recommend code complete 2 as a must read for getting the fundamentals right.
http://www.amazon.com/Code-Complete-Second-Steve-McConnell/dp/0735619670
First of all, for any software development questions you may have, I suggest you post your questions on Stackoverflow because the people there will surely provide you with answers.
Now, for a list of books I recommend:
JavaScript
JavaScript: The Definitive Guide; if you're new to JS, start with this one.
JavaScript: The Good Parts; not a beginner's book, but a must-read if you are going to use JS
If you are going to be using JS, you will most probably be developing using a framework, and for that I seriously recommend mastering jQuery because as they say, you will write less and do more!
CSS
CSS Mastery: Advanced Web Standards Solutions
Web Usability
Don't Make Me Think: A Common Sense Approach to Web Usability; the book that shows the users' perspective when viewing a website
Performance
High Performance Web Sites: Essential Knowledge for Front-End Engineers and Even Faster Web Sites: Performance Best Practices for Web Developers;if you want to get serious about performance for your websites
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
I'll suggest you for the Stanford Algorithm Part 1 and Part 2 on Coursera and its free while doing you'll get some assignment also and after the completion ,it will provide you a certificate .Here is my list of Online Courses to learn data structures and algorithms. It is sorted according to quality (in my opinion) :
Most of these courses are language independent. So you're free to do assignments in whichever language you want.
I also recommend this book - Introduction to Algorithms, 3rd Edition: Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, Clifford Stein
I would recommend reading Design Patterns: Elements of Reusable Object-Oriented Software. That book will give you the majority of design knowledge you would gain at this point in your career from college.
Taking a course will definitely help and I have a few book suggestions.
Intro to Algorithm
This is pretty much the holy grail on algorithms, used in many college CS courses.
Skiena's Algorithm Design
My personal favorite. Combines his Ph.D experience with real world problems.
Design Patterns by the gang of four. It is the essence of designing software architecture. It describes very common designs that have been tested time and time again, however it is broad and you have to specify your requirements but it is an amazing starting point.
(ps it actually is similar to design problems in civil architecture identified by Christopher Alexander. A Pattern Language (1977) & A Timeless Way of Building(1979).)
It really opens doors to how you should approach and choose the correct design. It's not language specific. The book however does have C++ examples
If you're new to C, read K&R.
Once you've done that (or if you already know C) then read THE book on Unix programming
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
Go read Clean Code: A Handbook of Agile Software Craftsmanship and write beautiful code yourself.
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.
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 have some questions about courses andsubjects for computer engineering ( Software Engineering)
CE and SWE are....a little different so I'll just talk to both a little bit.
CE is closer to Electrical Engineering specializing in Computers so you'd take more hardware oriented courses. Most CE curriculums [I've seen] take you through Circuit Theory, Electronics, Digital Systems, Signal Processing, Computer Organization (aka CPU design), Computer Networks, Embedded Systems, etc.
SWE is closer to applied computer science and is more about building applications and the software development process. So you'd start going through a lot of the early Comp Sci courses (Intro to Programming, Language Processors, Data Structures and Algorithms, Operating Systems, etc.) then you'd start leaning towards topics more closely related to building an actual piece of software like Software Project Management or Quality Assurance.
>Are they any books that you recommend to a complete noob ? Internet links ?
Who reads books?Other Tips:
Teach. Yourself. Git.
Video Tutorials:
Articles & Websites:
> I 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:)
K&R. If you're in a programming 101 class that involves C, just buy this book unless your prof tells you otherwise.
---
K&R has the reputation it has because they did an excellent job of balancing between "experienced programmers can use this as a reference" and "newbie programmers can use this as a starting point. Let me clarify: K&R will not make you a better programmer, but it is an excellent example of what industry professionals would consider to be a good piece of technical documentation.
If you're going to ever work with APIs or large amounts of technical documentation about software, this book will mirror the experience you get reading "good docs". In short, learning C from this books does an excellent job of showing you how much you'll have to figure out yourself and what information you should be expected to be given to you when working in the industry.
IMHO, knowing the basics is vital. For JavaScript, I recommend buying and reading, "JavaScript: The Good Parts".
https://www.amazon.com/JavaScript-Good-Parts-Douglas-Crockford/dp/0596517742/ref=sr_1_1
Awesome book Code , really helps you understand from a bottom up perspective. Super approachable without a CS background and does not need a computer in front of you to appreciate. Highly recommended.
It doesn't "know." Any logical operation (especially basic math calculations) can be broken down into binary digits, and a single binary digit (bit) can be represented as the presence or absence of electricity.
It's almost how if you were to build a sequence of pipes and valves, and pour water into the opening, the water would end up flowing through the same way each time. The pipes don't "know" where the water goes, it just happens.
A computer does the same thing but on a tiny scale with tiny electric pulses travelling through sequences of thousands of gates all connected to each other. Imagine that the buttons you hit on a calculator slightly change how the valves open and close. (or which opening to dump the water into) You hit enter, the water is poured, and the result shows on screen.
fair warning: I am not a hardware guy so this explanation is probably not 100% accurate.
If you have more interest in the subject I HIGHLY recommend reading this book: http://www.amazon.com/Code-Language-Computer-Hardware-Software/dp/0735611319
Thanks ;). Not so skilled on that and my advice might be misleading; though I got a background in cs:This would be my suggestion for someone beginning.
You can also search for those books pdf by using google hacks eg
filetype:pdf "title of the book here"orintitle:index.of "title of the book here"There are many courses on the internet. Coursera, Udemy, etc.. I recommend you to read at least a book about it. It really helps you to understand the logic and complexity. For data structures, I also recommend you to implement them by your self.
This is a very good book: https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844
This is the full MIT course: https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-006-introduction-to-algorithms-fall-2011/
I strongly recommend you to follow the course and read the book.
https://www.amazon.ca/Dont-Make-Me-Think-Usability/dp/0321344758
The way I learned UI design quickly was to put together some designs and ask for critiques from designers. There used to be a website where you could get critiques for your designs (in exchange for giving critiques yourself).
I recommend picking up a copy of either Programming Principles and Practice Using C++ or C++ Primer.
​
https://en.cppreference.com/w/ is a reference website, and is the goto resource for quick documentation lookups, etc. However, when learning C++ from scratch, a book is simply the best way to go.
I wrote a quick script to search the full text of HPMOR and return everything italicized and in title case, which I think got most of the books mentioned in the text:
Book title|Author|Mentioned in chapter(s)|Links|Notes
:---|:---|:---|:---|:---
Encyclopaedia Britannica| |7|Wikipedia|Encyclopaedia
Financial Times| |7|Wikipedia|Newspaper
The Feynman Lectures on Physics|Richard P. Feynman|8|Wikipedia|Full text is available online here
Judgment Under Uncertainty: Heuristics and Biases|Amos Tversky|8|Amazon|
Language in Thought and Action|S.I. Hayakawa|8|Amazon Wikipedia |
Influence: Science and Practice|Robert B. Cialdini|8|Wikipedia|Textbook. See also Influence: The Psychology of Persuasion
Rational Choice in an Uncertain World: The Psychology of Judgment and Decision Making|Reid Hastie and Robyn Dawes|8|Amazon |Textbook
Godel, Escher, Bach|Douglas Hofstadter|8, 22|Amazon Wikipedia|
A Step Farther Out|Jerry Pournelle|8|Amazon|
The Lord of the Rings|J.R.R. Tolkien|17|Wikipedia|
Atlas Shrugged|Ayn Rand|20, 98|Wikipedia|
Chimpanzee Politics|Frans de Waal|24|Amazon|
Thinking Physics: Understandable Practical Reality|Lewis Carroll Epstein|35, 102|Amazon|
Second Foundation|Isaac Asimov|86|Wikipedia|Third novel in the Foundation Series
Childcraft: A Guide For Parents| |91|Amazon|Not useful if your child has a mysterious dark side
Also, this probably isn't technically what the OP was asking, but since the script returned fictional titles along with real ones, I went ahead and included them too:
Book title|Mentioned in chapter(s)
:---|:---
The Quibbler|6, 27, 38, 63, 72, 86
Hogwarts: A History|8, 73, 79
Modern Magical History|8
Magical Theory|16
Intermediate Potion Making|17
Occlumency: The Hidden Arte|21
Daily Prophet|22, 25, 26, 27, 35, 38, 53, 69, 77, 84, 86, 108
Magical Mnemonics|29
The Skeptical Wizard|29
Vegetable Cunning|48
Beauxbatons: A History|63
Moste Potente Potions|78
Toronto Magical Tribune|86
New Zealand Spellcrafter's Diurnal Notice|86
American Mage|86
As others mentioned, TVTropes has a virtually-exhaustive list of allusions to other works, which includes books that aren't explicitly named in the text, like Ender's Game
Here's your bible:
Introduction to Algorithms, 3rd Edition (The MIT Press) https://www.amazon.com/dp/0262033844/ref=cm_sw_r_cp_apa_i_UbkDCb2H9VJ0B
Code: The Hidden Language of Computer Hardware and Software
The Mythical Man-Month
Peopleware: Productive Projects and Teams
Gödel, Escher, Bach: An Eternal Golden Braid
The Pragmatic Programmer: From Journeyman to Master
Coders at Work: Reflections on the Craft of Programming
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.
You should read this book. The best explanation of how computers work I know of.
I thought myself HTML/CSS with this book: http://www.amazon.com/gp/aw/d/1118008189/ref=redir_mdp_mobile
The book is design very well and eases you into everything with clear visuals.
And am still learning javascript with this sites regiment : http://javascriptissexy.com/how-to-learn-javascript-properly/
But I'm struggling finding the time to thoroughly understand it.
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.
American amazon link
You may want to narrow that down a bit, but okay, here are some highlights, with amazon links to help disambiguate.
http://www.amazon.com/Game-Programming-Gems-Adam-Lake/dp/1584507020/
www.amazon.com/Game-Engine-Architecture-Jason-Gregory/dp/1568814135/
http://www.amazon.com/Game-Engine-Design-Second-Edition/dp/0122290631/
http://www.amazon.com/Game-Engine-Architecture-Engineering-Applications/dp/012229064X/
http://www.amazon.com/Artificial-Intelligence-Games-Second-Edition/dp/0123747317/
http://www.amazon.com/AI-Game-Programming-Wisdom-CD-ROM/dp/1584500778/
http://www.amazon.com/Real-Time-Rendering-Third-Edition-Akenine-Moller/
http://www.amazon.com/Real-Time-Cameras-Mark-Haigh-Hutchinson/dp/0123116341/
http://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670/
There are many others, but looking at my shelf these are the big ones that stick out for recommendations.
Not an expert, but heard this title being bandied around: https://www.amazon.co.uk/JavaScript-Good-Parts-Douglas-Crockford/dp/0596517742
Two good books I'd recommend for getting started in exploitation:
Both are good resources to start with. Other than that, learn vdb/windbg/ollydbg/your debugger of choice, use it, and start making binaries do your whim. I started by debugging notepad back in the day.
There's a very popular management book about just this topic.
Introduction to Algorithms is an absolutely fantastic book. I've read it through a couple times. It's very well written and they have plenty of descriptive diagrams to help you intuitively grasp the different algorithms.
Read through this entire book before your program anything big.
This one should give you a good overview:
http://www.amazon.com/Practice-System-Network-Administration-Edition/dp/0321492668
There's a lot of information you need and I highly doubt you're going to get it all from one post, one individual or one source.
If you know your IT director is leaving then stay on his good side and bend his ear a bit on how things work there. This will save the owed-beers and frantic phone calls when some shit hits a fan and you can't Google your way out of it.
As for what to learn, Windows or Linux, etc; If you want to stay with this company for a year or few then look at what they need. Find problems, research solutions, test them, present them to your boss in the context of how your solution can save money and/or increase productivity. Is every user emailing you requests for assistance? Setup a ticket system. What's your backup setup like? If you don't have one then you need to figure that shit out quick. Backups are boring and second-class to most people until they need to recover an important file.
I also highly recommend picking up a copy of The Practice of System and Network Administration. http://www.amazon.com/Practice-System-Network-Administration-Edition/dp/0321492668. Most of us wouldn't recommend a tech book from 6 years ago but most of the information in this book is the non-tech stuff you need to know to do your job and do it well.
Oh, and keep lurking online and here in /r/sysadmin
Good luck.
Here are some things I (and I know others) have struggled with. I think the web is exploding with resources and information, so I don’t necessarily think we need to explain what a prototype is. There’s better places elsewhere to learn things about UX, but I think we could provide some good resources for not just people new to UX but everyone else too. I’m coming at this from what I wished I would have access to when I was trying to get into the field. I know that /u/uirockstar has some good walls of text that probably should be included as well. Feel free to suggest any changes to what I have here.
I really want to begin a career in UX/UI. What do I do?
Well, first it’s important to know that UX and UI are not synonymous. While many job postings combine them, UI is a subset of UX, just as research and information architecture are. UI is still important and if you can do both, you do increase your value. While many see UX as a research field at its core, the UX/UI title implies that it’s only about creating pretty things.
The first step is learning more about the field, which brings us to…
What kind of education do I need?
If you are still in school, there are more places recently that are offering courses in human-computer interaction. You can even try to create your own internships. There are very few UX specific schools, though they are starting to pop up, like Center Centre and General Assembly.
Yeah, yeah, that’s great. But I already graduated, so where do I start?
Any focus on people or technology can act as a solid foundation for learning UX. Because there has never been a set entrance path into the field, UX roles are filled with people from many different backgrounds. The most common degrees for those in the field though are design, psychology, communications, English, and computer science. link
There are a number of people in the field who are self-taught. There are tons of books, blogs, and designers (here are some helpful resources) which provide enough UX stuff to keep us all busy. When I first started reading about it, I quickly got overwhelmed because there was so much information available and most of it was intended for those who already had a pretty good grasp on things. The Hipper Element’s crash courses in UX and user psychology are great places to get a fairly quick overview.
There are books like The Design of Everyday Things by Donald Norman, 100 Things Every Designer Needs to Know About People by Susan Weinschenk and Don’t Make Me Think by Steve Krug that make for great first books.
UX Mastery has a great eBook for getting started, appropriately titled Getting Started in UX. Kevin Nichols’ UX for Dummies is both very readable, yet detailed. You can even buy the eBook if you don’t want people on the bus to think you’re a “dummy.”
Lastly, Fred Beecher has a very extensive Amazon list of recommended UX books, depending on what area you are looking to learn more about.
Great. I’ve read a whole bunch of stuff and have a pretty good idea how UX works. Now how do I get someone to hire me so I can gain experience?
Hey, easy there. While, yes, there are lots of UX jobs out there, very few are entry level and not many employers will hire someone who has only read about it and not actually done it. You can’t get a job without experience and you can’t get experience without a job. I know. Frustrating, right?
You have to prove that you can do it. One way to do this is site redesigns.
Go find a website that lacks in it’s user experience and figure out how to fix it. Maybe it’s a small business down the street from you or maybe it’s a feature on eBay you think could be better. Redesigning sites is a good way to practice a process and make mistakes on your own time. If you can involve the owner from that small business down the street, that’s even better because then you can get a sense of the customers (users) that you will be designing for.
Once you have done this, you have (some) experience! Start a portfolio and add to it!
But I have a resume. Why do I need a portfolio?
Resumes are great. But resumes won’t get you a job starting out. It’s a million times more effective to show potential employers what you have done, rather than showing them a resume showcasing that you are a team player and proficient in Microsoft Office. But you should still have a resume that outlines your UX skills.
But I’ve never worked in UX! What should I put on my resume?
You don’t need to put all of your old jobs on your resume if they are unrelated to the field. Most places still want to see some work history so they know you haven’t been living in a cave for the last four years, but they don’t care about how you sold vacuum cleaners or trained circus horses. Maybe you can relate some crossover UX skills to your previous work.
Back to portfolios. They are a lot like elementary math class in that you want to show your work. Potential employers are much more interested in how you made a design decision rather than the final result. If your portfolio just has a bunch of fancy wireframes, that doesn’t tell them how you took specific personas into account and you are simply showing them something that looks pretty. And just because it looks pretty doesn’t always mean it makes sense.
Okay. I have a portfolio with a few unsolicited site redesigns in it.
Congratulations! But I have some bad news. Are you sitting down?
No one wants to hire you yet. You haven’t worked on any “actual” projects that showed how your UX skillz helped a business. I know I suggested you do site redesigns to get practice and you should because that is work you can take to a nonprofit or another small business and say, “here are some trial runs that I’ve done that prove I know what I’m doing and now I can help you for free in exchange for adding it to my portfolio.”
They’ll probably be skeptical and say, “hmmm… I don’t think my website needs this newfangled user experience you speak of and—wait did you say free?”
You both get something out of it and you’re doing it pro bono, which relieves you the pressure of making one tiny mistake. (There is a great site called Catchafire that matches non-profits all over the country with people looking to donate their time and skills.)
Once you have a portfolio displaying your work and some experience, start applying! But there is one more aspect that goes into getting hired and that is the people who will hire you.
Ugh, but isn’t networking just using people for my own professional gain?
I had this same mindset and it probably delayed my entrance into the field. I wanted to rely only on the quality of my work and trusted the rest would follow. I avoided networking and meeting people in the field because I didn’t want it to seem like I was only mooching for a job.
But the fact is people are altruistic in nature and like helping others. Many people also enjoy talking about themselves, and those are the two main principles of an informational interview. You’ll also find that people are excited to help others get started since they remember how difficult it was (see: this blog post).
It wasn’t until I started getting those informational interviews and talking with people at UXPA and MeetUp groups that I learned another side of UX, but also got more familiar with more hiring managers or those that knew them. Whenever possible, people will hire those they know and like. Until you get out and start shaking hands and kissing babies, you will be just another faceless name in a stack of resumes.
Meeting with recruiters/staffing agencies is also a good route as they make money by finding you a job, so they have a vested interest in giving you constructive criticism.
I've heard that you have to live in a big city to get a job in UX.
Move. Just kidding. But while it’s true that larger cities like New York, San Francisco, and Seattle are full of opportunities, there are plenty of other places around the country that have jobs. Here are the top 20. If you live in a tiny city, expect a tougher time finding a position.
Okay, I got an interview. How do I not mess this up?
Some great advice is to go all UX on your preparation and treat the interviewer like a user.
.......to be continued.
Blogs:
Other:
Either K&R's The C Programming Language which is often considered "The C Bible" and is written by the authors of C, or a more recently published C Programming: A Modern Approach are both excellent and comprehensive learning resources. I personally recommend the latter because I believe it is more relevant and includes almost, if not all, the information in K&R.
C++ Primer is amazing, but definitely not for beginners. Since you're totally new to programming, I'd suggest learning a bit of Python first to get the basics down, or if you're feeling more adventurous, pick up a copy of K&R's "The C Programming Language", as it's a great introduction to lower-level programming, and it'll make C++ a lot easier to understand.
Some good freely available online Python books:
Invent With Python
Learn Python the Hard Way
Learn Python the Hard Way is easier than it sounds, I assure you. I would definitely recommend starting with Invent Your Own Computer Games With Python, though.
A couple more useful things to know:
Best one out there: https://www.amazon.com/Programming-Language-Brian-W-Kernighan/dp/0131103628/
I'm confused do you want someone with a native American accent, a British accent, or and American accent?
(Also in general videos tend to be a poor medium for learning the C language. Most learn from books like this)
Clean Code
Code: The Hidden Language of Computer Hardware and Software
As the title implies, it's not just about hardware, it goes into how software is written for hardware as well. But it's a really cool book, takes you from the very basics of circuitry (a battery, a light bulb, and wire) in the first chapter, and building only on things taught in the book gets you to a fully working computer.
There are some key concepts you want to get down if you really want to make the most of .NET
Design patterns are used over and over again in OO based systems. A good understanding of what they are for, and how they tend to be used will be helpful when trying to understand key framework extensions and 3d party libraries. I like to point people at Head First Design Patterns. The opinions on design patterns in this book are a bit dated and the examples use Java syntax but they are all relevant to the .NET world and will go a long way to understanding how class names and object structures are used in OO systems.
IMO One of the biggest concepts you'll need to understand in OO currently is the Inversion of Control pattern (also referred to as dependency injection) and the frameworks that provide it. Most modern .NET applications leverage some kind of dependency injection to simplify development and make unit testing and porting of classes easier.
NOTE: I understand many folks in the PHP world feel that PHP is a full OO system. While they have made strides in this area it is not a fully typed OO system. It's a procedural system twisted to provide some OO features.
This is easy, just review MSDN docs and samples. The biggest different you will see in the .NET world is a different opinion in general on casing of object and method names.
This is the part that seems the most overwhelming IMO. The language itself is fairly easy but understanding the huge amount of 1st and 3rd party libraries, frameworks and tools can be daunting. Since you come from the PHP world I am going to assume you are most interested in web based applications. What I would recommend is to pick a set of tools for your web stack and learn them. Once you understand the key pieces of a web application and how they interact you can start picking and choosing different components to meet your needs. I am going to suggest you start with the following stack to get started with a web application, this is the same stack I use for most of my clients making smaller functional websites or simple content driven systems.
Key Concepts for Modern .NET Apps
Some basic tools to help you:
Edit: Now with more links.
The biggest hurdles I had motivating myself to work on a project was never coding itself. It was always setting up the compiler, IDE, environment, finding something to work on, etc. The biggest one for me is blank page syndrome.
You don't need to convert to linux if you don't want to but it is good to get some experience in it if you can. I spent sometime setting up a headless Ubuntu server to manage my torrents and be network storage. It took a lot of time starting from scratch but the experience has helped me out.
http://www.ubuntu.com
http://www.reddit.com/r/linuxquestions
http://ubuntuforums.org/
If you want to continue with Java (which is a good choice). I believe the most popular IDE is Eclipse. It has great plugin support and has been used everywhere I've been. You can use it for development on android phones as well if you want to play around with mobile development.
http://www.eclipse.org
http://developer.android.com/tools/sdk/eclipse-adt.html
If your college is like mine, most of the later courses in computer science will not involve much coding at all but will involve a lot of math and knowing popular solutions to common problems (sorting, searching, graph theory, combinatorics). If you feel like you need to brush up on a language, there are a lot of web resources and books to help you.
http://www.codecademy.com
http://www.amazon.com/Effective-Java-Edition-Joshua-Bloch/dp/0321356683
http://www.amazon.com/Head-First-Java-Kathy-Sierra/dp/0596009208/ref=sr_1_2?s=books&ie=UTF8&qid=1382580434&sr=1-2&keywords=head+on+java
Computer science and software development is a broad field which makes scaling it daunting at times. The only way to make it less daunting is to just dive in and do it. Pick a project and work on it. You will encounter problems you have no idea how to solve and that's great because now you've found something you can learn (usually through Google).
Solve problems in manageable bits. If you try to implement your whole program at once it will seem impossible. Implement small portions of your project at a time. Trying to create a Java chat client? Just work on getting some basic sockets to work and build a library you'll be able to use going forward. This will make the goals seem manageable and help you modularize your code. It helped me with not feeling overwhelmed about my project's scope.
I hope I didn't sound condescending. I just wanted to share some things that have helped me. I don't think you are in a bad spot, you just need to stay motivated and find some things to work on to help you learn. If you have any specific questions I can try to help out, but there are other people on this sub that are far more knowledgeable than me.
Read JavaScript: The Good Parts by Crockford. He goes over structuring JavaScript in an OOP fashion. More generally it's a great book that will bring your understanding of JS from intermediate to the beginnings of expert.
If you like stuff like this you may be interested in my favorite book: Godel, Echer, Bach: The Eternal Golden Braid:
http://amzn.com/dp/0465026567
Edit: Also see the great MIT course with video lectures:
http://ocw.mit.edu/OcwWeb/hs/geb/geb/
Personally I am a UX generalist and work as a freelancer for early stage startups. I don't seek work on "game changer" projects like Fitbit, Snapchat and Pokemon Go but instead projects to improve processes that make current businesses more efficient and profitable. There is so much money to be made on these projects.
I design the app from top to bottom.
Here is some of the knowledge one would need to be successful:
App Design Basics
Overall Concepts
Psychology for microcopy (short instructions) and influence in design
Software needs
Places to see samples of work
My general suggestion is to start by designing something to solve a problem you care about for a business/industry you would want to work in. Don't expect perfection but practice constantly. Build your process and constantly improve for 6 months to 1 year. Then you're probably going to confidence, skills, and samples of work that are good enough to get a job.
Edit: formatting always gets me
> Crankys Guide to Sysadmin
I would honestly read that. It would make a great no-bullshit addition/supplement to something like The Practice of System and Network Administration.
here 'tis, and it was well uner $100
https://www.amazon.com/Practice-System-Network-Administration-Second/dp/0321492668
Best around.
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.
Congrats at getting into NEU. After reading a bit about the school, it sounds like you had to do work hard in your schooling to get into it.
On becoming a sysadmin, be patient. It's going to take a while. However, here are a few things to keep you busy:
exercise 1:
your world. DO NOT code in an IDE. Code in them all the way through
your degree.
personalizes your editor to you. Become a power user in whatever your
editor of choice is.
or zsh, but if you go with zsh, you have to learn bash anyway) to
customize your shell to your liking
exercise 2:
things into your shell that the oh-so-helpful! interwebz tell you to do, you should always understand
what they do before your run them)
strace -eread=all -ewrite=all -f nc -l -p 18100 127.0.0.1 > server_out 2>&1
strace -eread=all -ewrite=all -f nc -v -v -n -w 1 127.0.0.1 18100 < /etc/profile > client_out 2>&1
the file until you understand all of it and use wireshark to annotate everything
that is happening on the network in that pcap you had tcpdump write out all
the way up the OSI stack
exercise 3:
strace -eread=all -ewrite=all -f wget -qO /dev/null www.google.com > wget_out 2>&1
in the file until you understand all of it. include everything that happened between
your host and google (you don't know google's internals so just assume they're
running an apache server) over the network in the annotation. study a webserver
(apache, lighttpd, nginx) in debug mode with strace to understand what happened
on the other side of the network connection and use wireshark to annotate everything
that is happening on the network in that pcap you had tcpdump write out all the way
up the OSI stack
Read these whitepapers:
Buy this book and learn it inside and out. It is your bible.
If you do all this and learn it well, get a couple years experience under your belt (frequently there are computer labs that students can work in in college, that is one place to go) and then move to Silicon Valley or some other hub (sounds like you'll already be in Boston--there should be opportunity there). You'll never run out of work and you'll have the opportunity to try to work for the companies that make directly make money from their computing systems instead of being inside an IT shop that is a cost center in some company that does not appreciate you.
I think you need to keep an extremely open dialog with the COO. She's your boss. But she's likely hoping you become a trusted adviser rather than someone who needs to be managed.
Don't go in there helpless. But don't hide your deficiencies either. If you want to grow, she will help you do it. But you need to be self-reflecting and have ideas as to how to move forward.
The plan itself will come in the next suggestions.
Reflect on what was successful, and what could have gone better. Get a feel for the general process you defined. Could you have communicated the goals in a more organized fashion? Could you have defined milestones to help set management expectations? Should you have explicitly mentioned certain things weren't goals? What alternate plans where there, why were they rules out, and did management know about them? Were they properly budgeted? Was there adequate testing? Was it prioritized properly?
Do this for every singly project you can remember, then focus on identifying the strengths and weaknesses of each rollout. The strengths are what you were good at doing. The weaknesses were what you were bad at.
It could be as simple as "You know, looking back at this rollout, it all feels like one big step to me. I'm having trouble breaking them apart into steps, so it's hard to know when one piece of the project is done." You also need to identify why it's a problem and could get in the way of the project.
Look for patterns, and lay them bare. She'll be aware of some things and not on others. But you're demonstrating a clear willingness to grow, and that your solutions aren't just grasping at straws.
When you assess training options, you need to realize what you actually need. Do you need a class on project management, where you can ask an expert questions, or should you focus on ITIL standards, maybe you just need to start with a book, or maybe a book about modern it departments, or just a professional community.
Your project successes and sore spots, as well as your own comfort level will answer this question.
For any suggestion here, make sure you can justify its efficacy. How will the tool solve something that went wrong with a project?
Maybe the tool isn't a program, but a process . . . A process that you're technically building up by reflecting on project results and starting the dialogue.
They might want you to stop break/fix entirely. You won't be getting an assistant, but you'll be put in charge of someone with their own role, goals, and projects. THEY handle break/fix, rolling out an update, deploying a project.
So when a rollout moves past configuration and basic veirfication, they're role is to test it. Then give it to the people you direct. Then give it to everyone. They're not assisting you, they're following their own objectives within the parameters of their job description.
Maybe they see you as becoming a CIO type in 5 years: the budget, vision for the company, etc. will fall on your shoulders. You'll have a team of people under you doing technical work, while you handle technology from the business perspective. And maybe that's not what you want.
You might want to stay technical and specialize. You'll need project management skills as a Sr. admin or a manager, so your short term goals align. And they're not big enough for a CIO now anyway, so there's no harm.
But your building the expectation that, once you grow large enough, there WILL be someone over you. Because that's not what you want.
------------------------------
It's all about being comfortable, open, and trying to improve. Right now, you're deep into the learning phase. Own it. Everyone will respect you for it.
> No one else even has admin level access-- except me, very recently, with a big fight.
If this fight was with your current "computer guy," then you have big problems. They may be political, or technical, or security; he may be just offended that a family scion is encroaching on his "turf," or he may be afraid that someone will see his incompetence, or he may be disgruntled by the whole employment experience and planting some deadman switches. Take some time to mend fences; emphasize your need to learn this area of the business, and that you don't intend to displace him, and that the more you learn about what he does, the more you, as a future owner, will be able to advocate for the expenses necessary to keep "IT department" operating smoothly.
But also make it clear that the guy who pays the bills has placed you in charge, and that while you want to hand him his paycheck indefinitely, you are the guy signing the paycheck. Things are going to change, and he needs to get on board with that. He may not be willing to accept this change, in which case you will, unfortunately, have to quietly start planning to replace him.
Give him a chance; he may come around. It sounds like for a long time he's been able to run the "IT Department" however he wanted to, so this is a huge life change for him. I can't emphasize enough how much you need to make clear your loyalty to him, but that the price for that loyalty is his loyalty to you the other members of management.
> We have at least 8 computers still running XP.
Is this because computer guy didn't want to replace them (bad) or because users didn't want them replaced (still bad, but not computer guy's fault)?
> He keeps everyone's passwords on his phone.
This is almost certainly because of employees who think he should know everything about computers, including their password. I'd start with a culture change among employees that passwords are secret; that no one, not even the owner, should have their password; and that writing down or sharing a password should be a fireable offense. However, you need to be sure that passwords are easy to remember.
> Am I wrong to be thinking we shouldn't be having these frequent crashes/problems?
No, you're not wrong. Review your support agreement in detail. Start keeping meticulous records of the problems you're having and the impact to the business, in terms of number of users affected, lost hours of work, and lost revenues. Notify the software company of each problem. When you get to three problems, you need to politely but firmly request an escalation to someone who can address and prevent these problems systematically. There's a good chance that the software company will report back that these problems are the results of past decisions your company has made in contravention of the software company's recommendations.
> yelling at people
Does your company have a culture of yelling at people? Does the owner yell at people? Do managers yell at people? If so, then he's merely following his leadership. This is a culture change that you will have to work on, quietly and calmly, but forcefully. If / when leadership doesn't manage by yelling, then I would make it clear to computer guy that he gets one free yell, but a second one will result in harsh disciplinary action. If the job is that frustrating, get him a heavy bag for the server room and tell him "Whenever our employees are too stupid for words, excuse yourself, tell them that your boss 0110100101110100 told you you have to do something, and go punch the bag." This sounds like it might also be symptomatic of the end users expecting the computer guy to be able to fix anything immediately, and that if he can't, he's an idiot. This is something else that may require some culture change among the end users.
> it's impossible to fix
This is a different problem. If he says he can't fix something, you need to show him that he can. If he exhibits any behavior other than wanting to learn more, you need to shut him down hard. IT changes constantly. Anyone who doesn't want to learn something new all the time doesn't belong in IT.
> visual basic
Eh, unless you're doing custom software development, I'd let this slide as a quirk. Everyone has a right to stupid opinions about things they know nothing about.
> where do I start?
Buy a copy of The Practice of System and Network Administration I think most folks on this sub would agree that it's a good reference for a starting (or even a seasoned) sysadmin. Read it, encourage him to read it, and use it as a starting place for the changes you want to make.
TL;DR IT guy's behavior is symptomatic of a bad relationship between users and IT. It's not all his fault. You need to take charge of the situation and bring him along. If you can't handle one frustrated sysadmin, what makes you think you can run a company?
For those too lazy to find it, http://www.amazon.com/Practice-System-Network-Administration-Second/dp/0321492668 is the book on Amazon :)
The more significant differences between CS graduates and self taught programmers are algorithm design, important coding practices, and a lot of the mathematics.
Books on coding practices exist, but vary in various corporations or programming languages.
I highly recommend MITs book on algorithm design, to some it is considered the bible of all algorithm design.
As others have mentioned, Khan Academy is a great place to start for the mathematics. Particularly CALC I, II, Linear Algebra I, II, Discrete Math I, II.
It also couldn't hurt to look into some theory of computation topics (countability, turing machines, etc.)
Good on you for looking to grow yourself as a professional! The best folks I've worked with are still working on professional development, even 10-20 years in to their profession.
Programming languages can be thought of as tools. Python, say, is a screwdriver. You can learn everything there is about screwdrivers, but this only gets you so far.
To build something you need a good blueprint. For this you can study objected oriented design (OOD) and programming (OOP). Once you have the basics, take a look at design patterns like the Gang of Four. This book is a good resource to learn about much of the above
What parts do you specify for your blueprint? How do they go together? Study up on abstract data types (ADTs) and algorithms that manipulate those data types. This is the definitive book on algorithms, it does take some work to get through it, but it is worth the work. (Side note, this is the book Google expects you to master before interviewing)
How do you run your code? You may want to study general operating system concepts if you want to know how your code interacts with the system on which it is running. Want to go even deeper with code performance? Take a look at computer architecture Another topic that should be covered is computer networking, as many applications these days don't work without a network.
What are some good practices to follow while writing your code? Two books that are widely recommended are Code Complete and Pragmatic Programmer. Though they cover a very wide range (everything from organizational hacks to unit testing to user design) of topics, it wouldn't hurt to check out Code Complete at the least, as it gives great tips on organizing functions and classes, modules and programs.
All these techniques and technologies are just bits and pieces you put together with your programming language. You'll likely need to learn about other tools, other languages, debuggers and linters and optimizers, the list is endless. What helps light the path ahead is finding a mentor, someone that is well steeped in the craft, and is willing to show you how they work. This is best done in person, watching someone design and code. Also spend some time reading the code of others (GitHub is a great place for this) and interacting with them on public mailing lists and IRC channels. I hang out on Hacker News to hear about the latest tools and technologies (many posts to /r/programming come from Hacker News). See if there are any local programming clubs or talks that you can join, it'd be a great forum to find yourself a mentor.
Lots of stuff here, happy to answer questions, but hope it's enough to get you started. Oh, yeah, the books, they're expensive but hopefully you can get your boss to buy them for you. It's in his/her best interest, as well as yours!
I'd second unplugging completely: no computer, TV, electronics. If you insist on doing something CS related, Godel, Escher, Bach comes highly recommended.
This book is recommended all the time here.
The Practice of System and Network Administration
https://www.amazon.com/Practice-System-Network-Administration-Second/dp/0321492668/ref=pd_sbs_14_1/133-5038114-7566656?_encoding=UTF8&amp;pd_rd_i=0321492668&amp;pd_rd_r=0e7670a0-ca48-43ed-b0df-52a961b8b37e&amp;pd_rd_w=EHHBL&amp;pd_rd_wg=QxYjw&amp;pf_rd_p=d66372fe-68a6-48a3-90ec-41d7f64212be&amp;pf_rd_r=XY52WEZ55TBYCVPCX482&amp;psc=1&amp;refRID=XY52WEZ55TBYCVPCX482
I recommend The Practice of System & Network Administration. Next is probably the manual or a book about whatever monitoring system you're using (and spend the time you would have used to read another book to ensure you're monitoring everything). After that it depends what you're doing (busy public websites? Office IT?)
I keep seeing this book mentioned on this sub reddit, I haven't read it yet but it looks like what would help you: http://www.amazon.co.uk/The-Practice-System-Network-Administration/dp/0321492668
I don't work for ProtonMail but as someone who worked as a part of a development team, I feel like I have something to contribute to this discussion.
Getting the Bridge done as quickly as possible isn't simply a question of throwing as many people as they can at the problem.
First, it's an established fact in the software world that shoving more programmers at a project can actually make things worse, rather than better.
Secondly, not every developer brings the same thing to the table and has the same expertise.
The ProtonMail web interface uses one technology.
The encryption itself uses another, plus an even deeper level of theoretical understandings.
ProtonVPN is a completely different technology.
To stick with the house analogy, suggesting that building ProtonVPN means the Bridge isn't a priority is like suggesting that the plumbing in the house must not be a priority because you aren't pulling the carpenters off their jobs to help get the plumbing done as soon as possible.
This was famously used by the lead manager of the IBM OS360 development project, to explain why adding more programmers wouldn't make it possible to deliver the OS, sooner.
[Edit: For anyone who's interested, he wrote a book called The Mythical Man-Month on this exact topic.]
I really enjoyed the C# Player's Guide. There's a newer version now but this is what I got.
Edit: I'm glad you guys liked this book as much as I did. To OP, I would offer two more suggestions.
as a beginner you're stuck in a position where you want to learn how to do things, but also how to write them. i.e you don't only want to paint a painting, but you also want it to be pretty and admired.
for programming there's a lot of schools of thought on this subject, some guys prefer test-driven development, others domain-driven design.
some think comments outside of method parameters are good coding praxis, others think it's a code-smell because if you have to explain your code you probably wrote it in a way that makes it difficult to understand.
some think patterns are for hipsters, others are of the correct opinion (ahem) that they are standardised solutions for common problems.
all in all, if I could go back in time 15 years when I started programming, I would read the following if they were available at the time:
https://www.amazon.com/Domain-Driven-Design-Tackling-Complexity-Software/dp/0321125215
Domain-Driven Design is the concept of breaking your code into logical real world units and bundling your code around these objects so that it makes sense to program if you understand the real world your program is mirroring. i.e if you're making a fruit shop program, you might have a fruit seller, a register, a fruit warehouse, a process to deal with ordering fruit etc.
https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
Clean code talks not so much about the architectural patterns (outside of test-driven development) but rather what's good and bad about code at it's core. i.e
if(fruitStand.Amount < 5)
{
fruitHelper(fruitStand, 3434)
}
vs
if(fruitStand.Amount < dailySoldAverage)
{
OrderNewFruit(fruitStand, wholesaleDiscountCode)
}
outside of that, I think you'll find a lot more resources by simply researching the concepts these guys talk about. programming is constantly changing, as long as you have the fundamentals in place as these guys talk about you're golden as long as you're willing to learn.
Kauf dir das Buch: https://www.amazon.de/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882 oder lass es dir zu weihnachten schenken :)
Ansonsten: Wenn du schon einigermaßen was kannst guck dich mal auf github um, da gibt es zum Teil viele Projekte wo issues für Anfänger gelistet sind bei denen man relativ einfach in ein großes Projekt findet.
On this topic I’d like to recommend this book:
https://www.amazon.com/Working-Effectively-Legacy-Michael-Feathers/dp/0131177052
For one thing, although you may know a few languages (you mentioned Java, Visual Basic, and SQL, which isn't a language per se but you know what I mean), you may not know how to work with remote teams. You may not know how to use code versioning systems like git or SVN. You may not know how to use continuous integration software like Jenkins. You may not know how to use these and more, simply because you were never exposed to them in the course of your studies. And that's perfectly fine. You can't know everything. The problem though is that so many employers expect you to know all these things, even though you may have never even heard of them before this post.
That is exactly why /u/ResidentBiscuit said "the journey has only just begun." It's an exciting time!
I agree with what was said here:
> The Pragmatic Programmer contains 46 tips for software professionals that are simply indispensable. As the name implies, the book avoids falling into any kind of religious wars with its tips, it's simply about pragmatism.
> If you were to read only one book on this list, this is the one to read. It never goes terribly deep into anything, but it has a great breadth, covering the basics that will take a recent college-grad and transform him or her into someone employable, who can be a useful member of a team.
Don't forget The Pragmatic Programmer
I can highly recommend the Artificial Intelligence for Games book mentioned in this article too, has many useful techniques written in an easy to understand manner.
Debugging is investigation. Trial-and-error is voodoo.
See "programming by coincidence" in The Pragmatic Programmer, as well as this SO post.
I heard this book is good:
http://www.amazon.com/Programming-Language-2nd-Brian-Kernighan/dp/0131103628
It would be hard to evaluate yourself. It's probably best to link your Github work to someone and ask for their opinion.
PEP 8
The biggest hurdle is to accept that there's a Pythonic way of doing things.
I think a lot of people's first step to becoming Pythonic is by the way of using List Comprehensions.
Then there's generators, decorators, itertools, functools, collections, etc.
What it takes to be an Expert in Python
I'm sure his Python skill is amazing; I was too distracted by his VIM skill to pay attention.
These are language-specific things but it sounds as though you might want to get familiar with proper Software Engineering principles. Recognizing code smells and trade-offs between different Data Structures and Sorting Algorithms. You can start off with this excellent book on being pragmatic.
Pragmatic Programmer
Here are some youtube links where you can follow along and maybe even adopt their coding style. I don't remember if they are Pythonic or whatnot but I would guess that they are. They focus on projects you would have an interest in.
Sentdex
I recommend this book: Clean Code
We gave it to every new data scientist we hired at my last company.
Reductionism is important, but pure reductionism denies the existence of emergent phenomena (phenomena that depend on collective behavior of many simpler things). A very enjoyable book that covers this and many other topics at a popularly-accessible level is
Gödel, Escher, Bach: an Eternal Golden Braid. First published in the late 1970s, GEB is still delightfully fresh and exciting although a few minor elements are dated (e.g. computers now can beat humans at chess).
Not a video, but Code: The Hidden Language of Computers by Charles Petzold is really great.
There’s a book called, “Hacking: The Art of Exploitation,” that includes a lot of assembly.
https://www.amazon.com/Hacking-Art-Exploitation-Jon-Erickson/dp/1593271441
When I was starting to learn JS which was not that long ago at all and I am still learning I started with this video series:
https://www.youtube.com/playlist?list=PLz5rnvLVJX5VdVNddvRTj68X6miAWQ5pz
.then this one
https://www.youtube.com/playlist?list=PLz1XPAFf8IxbIU78QL158l_KlN9CvH5fg&amp;disable_polymer=true
.then this one
https://www.youtube.com/playlist?list=PL4cUxeGkcC9jAhrjtZ9U93UMIhnCc44MH
.then I read:
https://www.amazon.com/gp/product/0596517742/ref=oh_aui_detailpage_o07_s00?ie=UTF8&amp;psc=1
.then I read: https://www.amazon.com/gp/product/1430264489/ref=oh_aui_detailpage_o06_s00?ie=UTF8&amp;psc=1
and
https://www.amazon.com/gp/product/1118871650/ref=oh_aui_detailpage_o06_s00?ie=UTF8&amp;psc=1
.then I read:
https://www.amazon.com/gp/product/1491904240/ref=oh_aui_detailpage_o04_s00?ie=UTF8&amp;psc=1
and
https://www.amazon.com/gp/product/1491904240/ref=oh_aui_detailpage_o04_s00?ie=UTF8&amp;psc=1
.then
When I felt like I had a good enough grasp on vanillajs I started a giant project in Angularjs. Where I advanced my skills with git big time. Other resources I used are:
Atom: https://www.youtube.com/playlist?list=PLYzJdSdNWNqwNWlxz7bvu-lOYR0CFWQ4I
Rest api with MEN (lol): https://www.youtube.com/playlist?list=PL4cUxeGkcC9jBcybHMTIia56aV21o2cZ8
Docs are great for js: https://developer.mozilla.org/en-US/docs/Web/JavaScript
These were good for angularjs just incase you were interested:
https://www.youtube.com/watch?v=FlUCU13dJyo&amp;list=PL4cUxeGkcC9gsJS5QgFT2IvWIX78dV3_v
Honestly I cant link one of this guys videos because they all help sooooo much:
https://www.youtube.com/user/shiffman
You're definitely going to have to have a good working knowledge of Java (or some other similarly-structured OO-language like C#). That's honestly the biggest hurdle.
For that purpose, I recommend Head First Java. It's actually a book you can read straight through (if a bit goofy), but it does a better job of teaching Java and OO concepts better than anything I've ever come across.
After that, it's pretty much developer.android.com all the way home. Best of luck!
Head First Java ,
I've heard good things about Head First Java.
I haven't read this one, but I have read their C# book, which I highly recommend.
Head First Java
http://amzn.com/0596009208
I wouldn't call this game "finished," not even in quotes. Implement scoring correctly with display in the game and disappearing/respawning balls, correct deflection (as if the paddle were rounded), smoother AI motion and correct keyboard input (it's backwards and seems to rely on autorepeat). Then the game will be a "finished" pong game.
I can't comment on the Javascript code really, but if you're just learning Javascript, I really recommend reading Javascript: The Good Parts. It's a very short book on how Javascript really works, with no real attention given to irrelevant APIs (to game programmers) and the like.
I also recommend looking at one of the several HTML5 game libraries out there. I'm using ImpactJS, but it costs money. If you want something free, you could try looking at Crafty. They abstract a lot of things and you can focus on making games, and not with the details of HTML5 APIs.
First off, well done on getting one of your first apps out there. It's always a daunting step, especially when you're a beginner.
Some general things that will help you improve your current design and any other app you choose to create going forward:
varkeyword where applicable, using string interpolation etc, using auto-implemented properties for your classes, meaningful variable names etc).decimal.TryParse(...)instead ofConvert.ToDecimal(...), try...catch blocks, you always want to validate user-input as far as humanly possible.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.
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.
"Code" by Charles Petzold, if anyone wants the link.
JavaScript: The Good Parts
I highly recommend JavaScript: The Good Parts. I'd say to read that one first because it explains how you should think when programming in JavaScript. Knowing the syntax and function names is no good unless you how to use them.
I would definately recommend going for a book. Head First Java is the book I'm learning from right now, and I find it to be engaging, funny, and on point.
Yeah, you definitely should get a intro to java book and go along with it.
Perhaps check out Head First Java. It's ... a bit cheesy (cause they try to make it "fun"), but I found the material to be pretty solid for beginners.
Looks like someone uploaded it online, if you dont mind reading a textbook on a screen.
If you aren't doing well in your current CS courses, I'd highly recommend you focus on your university's courses and do well in them before deciding to bite off more than you can chew. Do some research and look for very basic coding books, not ones like this: https://www.amazon.com/Programming-Language-Brian-W-Kernighan/dp/0131103628/ref=sr_1_1?ie=UTF8&amp;qid=1478891766&amp;sr=8-1&amp;keywords=introduction+to+C+programming
Look for a bit more like this: https://www.amazon.com/Head-First-Java-Kathy-Sierra/dp/0596009208/ref=sr_1_1?ie=UTF8&amp;qid=1478891799&amp;sr=8-1&amp;keywords=Head+first+java
This depends on what language you are currently learning right now. Don't worry about entering contests and participating in projects or open source coding until maybe second or third year in especially if you haven't had any prior experience. Don't rush yourself into this, you need to make sure you absolutely understand the basics before going into things like hackathons or being very concerned about internships. Take your time learning, and don't enroll onto too many online courses if you think that you can't handle it. Yes, online courses can be helpful, and will only be really helpful if you treat them like real classes. I would advise against code academy or khan academy to learn languages since I've gone through them and they never helped me really grasp CS material better than a book and actual coding. Key here is to code as you go through a book, or else you'll never learn how to actually code. Do tons of simple programs and if you don't understand code bits, don't get frustrated. Copy paste the code, and use a debugger (a bit more advanced but very very helpful) to go through step by step what the code is doing.
Main Points:
Best of luck to you, remember to enjoy the process, and keep in mind that while you might not like coding, CS isn't coding. It's the principles that underlie what we can do with code. A lot of it comes from really basic logic, you will be surprised in the future how easy some things can be to understand with basic step by step thinking.
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.
I think this is the problem:
this is what you thought you were saying:
> I think "months" is an exaggeration and I think a lot can be picked up by just reading existing docs.
this is what people thought you were saying:
> I think I know better than The Mythical Man-Month. A new programmer can jump right in at 100% without requiring any instruction or support.
this is what you were actually saying
> I don't buy that new programmers need to be taught existing code...
I mean dude, come on. Either you're backpedalling now or you suck at expressing yourself.
Read about the topic.
Practice.
Set yourself little challenges that you work on, or learn a new language/platform/environment. If you're just starting, try different easy programming challenges you find on the 'net. If you've been doing this a while, do something more sophisticated.
The challenges I've set for myself in the recent past include writing a LISP interpreter in C, building a recursive descent parser for a simple language, and implementing different algorithms I've encountered in books like Numerical Recipes and Introduction to Algorithms.
(Yes, I know; you can download libraries that do these things. But there is something to be gained by implementing quicksort in code from the description of the algorithm.)
The trick is to find interesting things and write code which implements them. Generally you won't become a great programmer just by working on the problems you find at work--most programming jobs nowadays consist of fixing code (a different skill from writing code) and involve implementing the same design patterns for the same kind of code over and over again.
----
When I have free time I cast about for interesting new things to learn. The last big task I set for myself was to learn how to write code for the new iPhone when it came out back in 2008. I had no idea that this would change the course of my career for the next 9 years.
Hi PizzaPartify,
I believe that different companies/teams will place emphasis on different skills. When I was helping to hire software engineers for EA's motion capture studio, I liked to see candidates who showed a strong aptitude for engineering code to be maintainable. For me, this meant a familiarity with design patterns and software development processes (like Test Driven Development or Extreme Programming). In my department, much of our code was in C++ and Python. However, other departments would use languages like Java, C# or ActionScript - depending on the project.
It would be helpful to know what role you are applying to.
To answer your specific questions:
Regardless of the language you're working in, I would also recommend Design Patterns by the gang of four (http://www.amazon.ca/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612).
A game-specific recommendation is Game Engine Architecture by Jason Gregory (http://www.amazon.ca/Game-Engine-Architecture-Jason-Gregory/dp/1568814135). It doesn't matter if you intend to write an engine or not, it is immensely helpful to understand how they work.
I own all of the Game Programming Gems books but use them more as a reference library. The books above will be more helpful right now.
I hope that helps.
Here are my nominations:
I haven't read them all through but have started on the Time Management book. So far so good.
The Practice of System and Network Administration, Second Edition
UNIX and Linux System Administration Handbook - 4th Edition
[TCP/IP Illustrated, Volume 1: The Protocols - 2nd Edition] (http://www.amazon.com/gp/aw/d/0321336313/)
These should be part of every ops department's library, if not already in your own personal one.
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.
well depends on what you want to learn. Do you only want to do webdev stuff or learn a ton about CS concepts? I'm going to answer in terms of learning CS stuff, but first here's a page on how to go from knowing nothing to knowing a wide range and depth of CS topics: you do this, you'll be a grade A software engineer!
OK, moving on. First the basics which it sounds like you've got covered.
OK, now where it sounds you stand. Learning the Advanced stuff.
anywhoooo that's kind of an overview/recommendation... feel free to ask any more questions/clarifications/suggestions for resources.
C Interfaces and Implementations has some decent advice for designing C programs. This is also a skill which you 'll develop with time (e.g. over your entire career) so don't worry too much about figuring it out immediately; it requires experience. As you work on various projects you'll get a sense for what works and what doesn't so that over time you'll have developed strategies for solving particular types of problems.
OOP concepts are still valid even though C may not have ways to necessarily implement them within the language proper. Object-Oriented Software Construction is a fantastic book for learning OOP concepts. As your C experience grows, you'll begin to see ways of implementing some of those design strategies with C, even though it's not an OO language.
Knowing when to use what type of data structure can also aid in simplifying your code base. The standard book for this is CLRS, but for C specific implementations and advice, see Algorithms in C.
I think this article is great. Writing good maintainable code is a must for those that want to advance with their career. I'd suggest Clean Code to those that want to get better at this. Note that this is not a fun book, the first chapter even goes into detail saying how it's going to be a slog to get through. Other things to do are submit code for regular review, try and work with others as much as possible since it will make you much better at programming, and take your time doing things the right way, rather than the fast way. Speed comes later.
There's a book called Clean Code that may interest you. I have it and still need to read through it, but it's been recommended countless times on here.
I'd go read books about the A+ cert (you don't need to certify but it's great material).
For other technical things I recommend a lot of books that are amazing:
Use technology books to learn processes, not end results. To be a better IT person, you should know how computers work as a system, not how to do say "Map network Drive in Windows", learn how those drives are mapped, what are the underlying fundamentals?
Clean Code is a great resource that touches on this topic and several other coding conventions.
http://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
Uncle Bob (the author of Clean Code) recommends that you organize your methods based on the context and the level of clarity. He would suggest putting the high level code near the top with the smaller helper methods near the bottom.
It compares a class to a newspaper. In a newpaper, you generally have the Subject at the top, with a high level description of the events that have taken place. As you read down the page, the articles will change from high level descriptions to low level details of the events.
Obviously, there are sometimes exceptions to this suggested rule.
TLDR: I wouldn't organize methods alphabetically. I would organize them logically from high level to low level.
I've heard this book discussed before; perhaps you would be interested in it?
http://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
If you want to pick up some Cryptography, The Code Book is a great intro.
Pragmatic Thinking and Learning is good for learning to learn.
The Pragmatic Programmer is good for project code planning and learning how to write code in a well thought out way.
Ethernet: The Definitive Guide is a good read if you want to get up to snuff on your networking, though it can be a bit dry at times.
The Pragmatic Programmer
I started to teach myself C, and this book has been an unbelievable resource. It starts pretty basic, but it gets into the meat of C pretty quickly.
"The C programming Language" is an excellent book. I learned most of the concepts and coding from that book.
Kernighan and Ritchie's The C Programming Language
It will teach you almost all you need to know. It is written by the creators of C and is still the best way to learn C.
I even use it as a reference for parts of C I do not use often.
Also, you should try to be running a unix os, since c programming will be much more integrated and easier.
link: http://www.amazon.com/Programming-Language-Prentice-Hall-Software/dp/0131103628
I recommend reading and working through The C Programming Language, which will likely be your textbook. Java syntax comes from C/C++, so that part will be somewhat familiar. C is a lot more low-level, though.
/me suggests reading Working effectively with legacy code which helps by providing more tools for proactive handling of "legacy issues".
You should read Clean Code.
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.
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.
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
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.
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.
Head First Java. This is an outstanding, fun, book and an easy read. Good explanation of OO principles as well.
After that, just start coding. I had previously done C and Perl, but HFJ is written for the absolute beginner.
You're an experienced programmer: this
You're a mathematician/scientist/engineer/etc: this
You are "ok" with another language: this
You're more of a "video tutorial" learner: this (and your local library probably gives you free access, seriously check)
You're completely new to programming: this
You're 9 years old: this
I'd recommend you start with the book "Code", which handles just this progression: http://www.amazon.com/Code-Language-Computer-Hardware-Software/dp/0735611319
From there, investigate operating system development. The Minix OS is very well documented.
Riding on your top post coattails...
The Elements of Computing Systems and Code by Charles Petzold are exactly what you want.
Code goes through number systems, basic information theory, circuits (from gates on up), memory, machine code and programming languages, all with accessible diagrams and explanations.
TECS has you build an actual working computer from the ground up.
Code Complete: http://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670
Applicable to any OO language you are using.
Hey man. Good to hear that you are interested in programming. :)
I don't think "books" is a good suggestions. There is a lot to read and not a lot of time in the world. Plus, programming tends to be more fun.
That being said, however, I am going to go ahead and recommend reading Code Complete. I think that book should be required reading for every programmer. You will learn a lot and it is also a fairly amusing / interesting read.
I would also like to suggest that you use StackOverflow and follow interesting conversations in it. One of the tricks to programming is to become very engrossed in it. Find things you find interesting and read/learn just for the sake of it. If you think you know language 'X' well -- go to StackOverflow, sort by votes, filter by tag and tag the language you want to read about. I guarantee you will find a lot of "Woah, I did not know language 'X' could do that."
One last thing w.r.t all the 'what languages should I learn' hullabaloo. Start a little higher level. It sounds like you want to learn an Object-Oriented language. Do you know what your other options are?
http://en.wikipedia.org/wiki/Comparison_of_programming_paradigms#Main_paradigm_approaches
There's a quick overview of the different 'types' you'd expect to see. OO is a clear one, especially for industry development, but functional languages and others may also end up being used for your job. :)
EDIT: A little more on topic. I started with C++ in school. Some concepts were difficult -- pointers, references/pass-by-reference/de-referencing, and to a lesser extent garbage collection / memory allocation.
The main argument for learning C++ first is that it gives you good fundamentals. Every programmer should know what a pointer is. And a double pointer, for that matter! The main argument against learning C++ is that you can blow your foot off much easier than in Python. And that's no fun. And if you're the type of person who isn't ...tenacious enough to try and repair your own blown off foot -- perhaps a higher-level language would be a better choice. In this way you can become more accustom to the frustrations of coding (and how to cope) before introducing more complex issues.
That isn't to say you can't create just as large a clusterfuck with Python. You can. It has its own nuances. It's just that the library support (code already written for you) is going to be more extensive. A good comparison would be driving an old car vs a new car. The engine is harder to repair in the new car (can't get at the parts), runs better, but you don't get a feel for whats in the engine. Its more of a black box. That old '57 Chevy (C++) has its engine laid bare (not as much as C), but if you're no mechanic you might break your car and abandon it.
Just do what you find fun! You're still young :)
Code Complete (haven't yet read ed. 2, but the first edition was tremendous)
Go through "Hacking: The Art of Exploitation" by Jon Erickson and learn the skills as needed. When you can make it (and I mean not just do the examples, but understand the how and why in each example) through his book you should have some good base knowledge and an idea what subjects you enjoy, pursue them in that order after that.
amazon link to book
edit formating
A similar question was posted on Quora not long ago, and the main recommendation was Code by Charles Petzold:
http://www.amazon.co.uk/Code-Language-Computer-Hardware-Software/dp/0735611319/ref=sr_1_1?ie=UTF8&amp;qid=1395088237&amp;sr=8-1&amp;keywords=code+charles+petzold
Having subsequently read the book I think it's a fantastic introduction, and goes through everything from the importance of binary code and applying Boolean logic to circuits, to the details of the inner workings of the first microprocessors, and all in an interesting and engaging way.
Your post has too little context/content for anyone to give you particularly relevant or specific advice. You should list what you know already and what you’re trying to learn. I find it’s easiest to research a new subject when I have a concrete problem I’m trying to solve.
But anyway, I’m going to assume you studied up through single variable calculus and are reasonably motivated to put some effort in with your reading. Here are some books which you might enjoy, depending on your interests. All should be reasonably accessible (to, say, a sharp and motivated undergraduate), but they’ll all take some work:
(in no particular order)
Gödel, Escher, Bach: An Eternal Golden Braid (wikipedia)
To Mock a Mockingbird (wikipedia)
Structure in Nature is a Strategy for Design
Geometry and the Imagination
Visual Group Theory (website)
The Little Schemer (website)
Visual Complex Analysis (website)
Nonlinear Dynamics and Chaos (website)
Music, a Mathematical Offering (website)
QED
Mathematics and its History
The Nature and Growth of Modern Mathematics
Proofs from THE BOOK (wikipedia)
Concrete Mathematics (website, wikipedia)
The Symmetries of Things
Quantum Computing Since Democritus (website)
Solid Shape
On Numbers and Games (wikipedia)
Street-Fighting Mathematics (website)
But also, you’ll probably get more useful response somewhere else, e.g. /r/learnmath. (On /r/math you’re likely to attract downvotes with a question like this.)
You might enjoy:
https://www.reddit.com/r/math/comments/2mkmk0/a_compilation_of_useful_free_online_math_resources/
https://www.reddit.com/r/mathbooks/top/?sort=top&amp;t=all
Algorithms, Design Patterns, VCS, being familiar with typical CS interviews questions and something that will be really needed
Some Books:
For Algorithms:
http://www.amazon.co.uk/Algorithms-Sanjoy-Dasgupta-ebook/dp/B006Z0QR3I/
http://www.amazon.co.uk/Algorithm-Design-Edition-published-Springer/dp/B00E28CR4I/
http://www.amazon.com/Introduction-Algorithms-Thomas-H-Cormen/dp/0262033844/
Design Patterns:
http://www.amazon.com/Design-Patterns-Explained-Perspective-Object-Oriented/dp/0321247140/
http://www.amazon.com/First-Design-Patterns-Elisabeth-Freeman/dp/0596007124/
http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612/
http://www.amazon.com/Design-Patterns-Dummies-Steve-Holzner/dp/0471798541/
Interviews:
http://www.amazon.com/Cracking-Coding-Interview-Programming-Questions/dp/098478280X
http://www.amazon.com/Programming-Interviews-Exposed-Secrets-Landing/dp/1118261364/
Start with Don't Make Me Think: A Common Sense Approach to Web Usability, 2nd Edition
Then read GUI Bloopers 2.0, Second Edition: Common User Interface Design Don'ts and Dos
Then possibly The Design of Everyday Things
And follow up with The Non-Designer's Design Book
Don't Make Me Think
Sounds like you already know what you want to do! I'm on the Microsoft side of the house, love scripting, and am fortunate enough to spend the majority of my day working in PowerShell.
Definitely check out The Practice of System and Network Administration if you haven't already, it lays a great foundation for the areas in IT.
If you go the Linux / scripting route, read up on and spend more time with shell scripting and Python (perhaps Ruby if you get into config mgmt). If you go the Windows route, read up and spend more time on PowerShell. Either way, being able to code and automate will be very important in our field, it sounds like you are on the right track.
Cheers!
http://www.amazon.com/Practice-System-Network-Administration-Edition/dp/0321492668#
Et godt sted at starte er bogen “The mythical Man-month” af Fred Brooks. https://www.amazon.com/Mythical-Man-Month-Software-Engineering-Anniversary/dp/0201835959
IT-projektledelse er på mange måneder ikke anderledes end projektledelse generelt, men der kræves en væsentlig forståelse for, at opgaverne som oftest kan være enormt komplekse af natur.
Du vil derfor opleve, af din aller aller største hurdle ikke er dit team, som står for eksekveringen, men dine interessenter (aka stakeholder management). Uden at smøre unødigt tykt på stereotyperne, så er det de færreste “projektsponsorer” eller lign interessenter fra forretningssiden, som egentlig har bare en snært af sans for hvorfor IT/softwareudvikling er svært at tids/budget-estimere.
Et klassisk eksempel:
Udfordring nummer 2 er, at din interessenter/ resten af forretningen stort ser altid lever i en “waterfall” verden, også selvom I kører agile eller lign. metoder.
Dvs, at I som team ofte kan føle jer enormt klemt af, at den eksterne verden ikke forstår eller gider spille med indenfor jeres best practices. (Men det lyder fedt for virksomheden at proklamere “vi er agile”).
Anyway, det skal siges at jeg til dagligt arbejder med product management, så det er lang tid siden jeg har levet i en “project-only” verden.
Edit: typos
I can't believe noone has mentioned The Mythical Man Month yet. If nothing else, it will help you give better time estimates for your work.
Yea, understand this book cover to cover and you'll get any silicon valley job easily.
In the theoretical field of complexity...
The 1979 version of Introduction to Automata Theory, Languages, and Computation by Hopcroft & Ullman is fantastic and used to be the canonical book on theoretical computer science. Unfortunately the newer versions are too dumbed down, but the old version is still worth it! These days Introduction to the Theory of Computation by Sipser is considered to be the canonical theoretical computer science text. It's also good, and a better "introduction" than H&U. That said, I prefer H&U and recommend it to anyone who's interested in more than getting through their complexity class and forgetting everything.
In the theoretical field of algorithms...
Introcution to Algorithms by Cormen, Leiserson, Rivest and Stein is dynamite, pretty much everything you need to know. Unfortunately it's a bit long winded and is not very instructive. For a more instructive take on algorithms take a look at Algorithms by Dasgupta, Papadimitriou and Vazirani.
Can't go wrong with Introduction to Algorithms
Another popular algorithm book is Skiena's Algorithm Design Manual
Another one suggested by one of my professors is Algorithms by Robert Sedgwick
Meh, these sort of definitional quibbles annoy me. What is the point of manufacturing a distinction such as this that pretty much exists solely as a "gotcha"? The fundamental idea at work is that you're re-using the answers to subproblems in order to computer the answer to the big problem. As long as you've got that idea down, what's the huge philosophical difference in the order that the subproblems are computed? I'm not saying that the distinction is invalid - there is an difference for sure - just not of great importance. In fact, if I were explaining it, I'd introduce DP as a particularly clean form of memoization -- one where you have spent effort to formulate an algorithm in a way that guarantees all subproblems are solved before their solutions are required in the next tier of problems.
I'm not 100% sure, but I think I remember Introduction to Algorithms explaining it this way. They may also have gone for taxonomy where memoization is the specific mechanism of storing results of previously-solved problems and dynamic programming is the application of such to algorithms (thus there would be top-down dynamic programming and bottom-up dynamic programming).
Edit: syntax (changed "computed in" to "computed")
Do you already know how to program?
If not, then read Structure and Interpretation of Computer Programs.
If yes, then get C++ Primer by Lippman.
The newest edition of C++ Primer also covers C++11. I'd recommend reading that before reading TCPPPL. See http://www.amazon.com/Primer-5th-Stanley-B-Lippman/dp/0321714113
I would supplement your class with one of the many great C++ books out there, because there are many ways to learn C++ but few of them are good (or even "right") ways.
You should be careful to distinguish between best practices from C++ and the new ones in C++11, and I've found that many courses tend to teach C++ as if it's just C with some extra features.
Of note, some really good books are:
At least as good starting points on the "new" C++, and I'm sure others have some really great suggestions too.
Beginner and Novice are the same thing. It sounds like you're trying to transition of Beginner to Intermediate.
You really should stop trying to write your own framework for the moment, and start using a mature framework. Good frameworks aren't trivial to write, and generally require an expert level of knowledge to write well.
The thing with a framework is that it helps remove you from a lot of boilerplate code - that is, common code everyone would normally need for any give web project. The easiest way for you to bridge the gap is to begin using and understanding code that is better than yours. Don't reinvent the wheel until you understand how to make a better wheel.
Design patterns are everywhere in good code. The trick is to recognize when a design pattern is being used, and to understand why it's being used. In order to help with this, it's commonly recommended to read Design Patterns: Elements of Reusable Object-Oriented Software. This is a book every programmer should own regardless of the language they use.
The amount of planning you have to do scales with the complexity of the project.
Professors drill the importance of planning, documentation and unit testing into students because it is extremely important and once you start your career if you're a poor planner it's going to come back to haunt you.
However, when you're working on a simple project that's not intended for public release you don't have to go overboard with docs unless you just want to practice.
My own process usually starts with me jotting down an idea; I find that writing it out helps me to get a better grasp on the overall feasibility.
Once I'm satisfied that I actually have something I can implement I'll diagram the flow of the application, and maybe do some wire-frames.
I usually find that this is enough of a launching pad for a simple personal project.
Professional projects are a different ballgame, because as I said, the amount of planning you have to do scales with the complexity and size of the project. It's in the professional environment that all of the things your professors are teaching you will become really important.
So, to answer what I think was your question,
>So how does one end up with 20 classes connected with each other perfectly and a build file that set everything up working flawlessly with unit test methods that check every aspect of the application?
This comes about more in the implementation phase than the planning phase. I've heard it said that in war "no plan survives contact with the enemy" and you'll find this to be true in software development as well. Even when you plan really well you'll sometimes have to go back to the drawing board and come up with a new plan, but that's just part of the process.
Some books that I recommend on the topic are Hackers and Painters - Paul Grahm and I think every software dev should have a copy of Design Patterns
The former is a collection of essays that might give you some useful perspective on the process of writing software.
The latter is more of a reference book, but it's helpful to become familiar with the patterns covered in the book so that you don't find yourself re-inventing the wheel every time you begin a new project.
As for the other part of your question (apologies for addressing them out of order)
>My new "bottleneck" writing code is the structure. I end up having huge classes with way to many public methods. I might as well just write a script with everything in one file. Almost anyway.. I try to write OO, but I often get lazy and just end up with not very elegant systems I would say.
Don't be lazy, because as you're already seeing, it comes back to bite you in the ass.
As you're writing your code you have to be mindful of the complexity of the project as it grows around you, and you have to periodically take a step back and look at what you've created, and re-organize it. This kind of goes back to what I was saying earlier about no plan surviving enemy contact.
So when you find yourself creating a new class that you hadn't thought about, be mindful of where you put it.
Should you create a new file (yes, of course you should), new folder?
Do you have a bunch of similar classes doing the same thing? Should they inherit from one another?
Be especially mindful of copy and pasting from one are of your code to another, generally speaking if you're doing this you should probably be writing a function, or using inheritance.
It's up to you as the developer to make sure your project is organized, and now-a-days it's really easy to learn how to best organize code by looking through other peoples projects on github, so there's really no excuse for it.
Hope that helps, good luck.
From what I understand they're a way to structure your code to solve specific problems. An example would be a combination of the Factory pattern and the Component pattern as a way to use data driven design to create "things" in your world (I have enemy Bob, Bob.txt/Bob.xml/Bob.whatever has all the information to create Bob. The "factory reads in this info, and then handles creating the entity and components.)
If you'd like to learn more there's the gang of 4 book Design Patterns: Elements of Reusable Object-Oriented Software, and for a focus on design patterns in games I liked gameprogrammingpatterns.com
If you are willing to sacrifice the "language" requirement, you could go for something like Introduction to Algorithms which will definitely make you a better programmer, regardless of your field. It contains, directly or indirectly, the solutions to 95% of the problems you'll encounter, and gives you the tools to deal with the last 5%.
Start with a good algorithms book like Introduction to algorithms. You'll also want a good discrete math text. Concrete Mathematics is one that I like, but there are several great alternatives. If you are learning new math, pick up The Princeton Companion To Mathematics, which is a great reference to have around if you find yourself with a gap in your knowledge. Not a seminal text in theoretical CS, but certain to expand your mind, is Purely functional data structures.
On the practice side, pick up a copy of The C programming language. Not only is K&R a classic text, and a great read, it really set the tone for the way that programming has been taught and learned ever since. I also highly recommend Elements of Programming.
Also, since you mention Papadimitriou, take a look at Logicomix.
I would look for a template that you think is good for his content and then adapt it. I'm not saying that you copy it, but you can inspire yourself in another's work. I'd suggest http://themeforest.net/
That said, you are not changing the design, you are changing the position of the content. You could maybe start rethinking the content tree. I would make always available the contact info. It's the best thing to do for the users and clients love to be always available ;)
You could think about the design in little pieces. For example: you have a book gallery to redesign, look for other book galleries that you like and then design stephen's.
This is my attempt. It's super simple. but I think that's what make it understandable.
http://i.imgur.com/VqwTj.png
Ask me anything you need.
I would also change the body text line-height: to 140% to make it more readable.
*edit: I would also make bigger the 'men and women' titles.
I suggest you to read Don't Make Me Think. It's a little old usability book that you could be read in half a day and will blow your mind :)
PS. Sorry for my English.
This is quite the mess you've got here. I'm sorry to be so negative, but there isn't a single thing i like about this.
Your 'nav'/login section is too large, garish & out of place. Not to mention the fact that the login button shouldn't be in the nav.
The colour scheme feels like an afterthought. Everything seems so random. I don't know why your two lists are styled so differently.
Your text is too large in places and the line height is too small. Everything is very bunched up and cluttered.
The arrow on the about link is nothing short of horrific.
Going back to the text, there is no sense of hierarchy. Decide what information is most important and make sure it is clear at the top of the website. Secondary info can go below the fold if needed to keep it from looking messy.
The contact us bit again looks like an afterthought.
The logo is hideously lazy.
Overall, i don't know where to look first to find the information i'm looking for. Don't make me think!
My advice? Start again. But before you do so, have a look at some similar websites for inspiration, USE A GRID!, if you want to do a text-based design, learning the basics of typography is an absolute must.
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!
Pick up a copy of The Practice of System and Network Administration. It's a great starting point for overall support and admin methodologies.
I recommend you become familiar with the following terms:
Rules, Regulations and Guidelines; ACR guidelines, NRDR (e.g. Lung Cancer Screening), AAPM TG-18, HIPAA 1996, HITECH 2009, MACRA 2015, PAMA 2014 (especially AUC aka CDS), PQRS, etc.
IHE (actor, transaction, profile)
DICOM (entity-relationship, GSDF, GSPS, IOD, DICOM service, SOP Class, RESTful services e.g. WADO)
HL7 (message, message type, segment, field, component, FHIR)
Image pixel data (bit, byte, bit depth, grayscale, histogram, pixel, voxel) and Image Processing (Gaussian, Laplacian, Sobel, etc.)
Speech Recognition (aka Voice Recognition), DICOM Structured Reports
High Availability and High Performance (Business Continuity, Disaster Recovery, Fault Tolerance, Failover / Failback, hot / warm / cold spare, Geographic redundancy, clustering and mirroring, RAID (RAID 0, RAID 1, RAID 5, RAID 6, RAID 50, etc.)), virtualization, iops
Networking (Packet Switching, OSI Model, TCP/IP, "Well Known Ports" - Network Protocols (DNS, DHCP, FTP, FTPS, HTTP, HTTPS, SNMP, telnet, ping, traceroute, netBIOS, netstat, ipconfig), DSL, ISDN, T-1, T-2, T-3, DS-1, DS-2, DS-3)
Encoding, Encryption and Compression (SSL, TLS, RSA, Run Length Encoding, Big Endian, Little Endian, JPEG, JPEG2000)
Nomenclature and medical coding (RadLex, LOINC, SNOMED, CPT, ICD)
Information technology Management (ITIL, ITSM, SaaS, SLA, SOA, QoS)
https://www.abii.org/About-PACS-Administrator.aspx
https://www.abii.org/docs/Certification-Guide.pdf
http://siim.org
http://siim.org/?page=ciip_study_resources
http://siim.org/?page=pii_textbook
http://www.otechimg.com
http://ihe.net
http://ihe.net/Resources/upload/ihe_radiology_users_handbook_2005edition.pdf
http://medical.nema.org/standard.html
http://www.hl7.org/implement/standards/index.cfm?ref=nav
http://www.hhs.gov/ocr/privacy/hipaa/administrative/privacyrule/index.html
http://www.hhs.gov/ocr/privacy/hipaa/administrative/securityrule/index.html
http://www.hhs.gov/ocr/privacy/hipaa/administrative/enforcementrule/hitechenforcementifr.html
http://www.fda.gov/Radiation-EmittingProducts/MammographyQualityStandardsActandProgram/default.htm
http://www.acr.org/~/media/AF1480B0F95842E7B163F09F1CE00977.pdf
http://www.acr.org/~/media/3E08C87AD6E6498D9E19769E5E5E390D.pdf
http://deckard.mc.duke.edu/pdf/Samei-TG18.pdf
http://www.amazon.com/Practice-System-Network-Administration-Edition/dp/0321492668
http://www.pmi.org
>However with servers, and everything else in the data center, I'm scared to do anything to them, because of fear of crashing the system.
This is actually a healthy and normal attitude to have, frankly. If you make a mistake, you aren't just interrupting one person's workday but potentially everyone's. I would use a very conservative approach to handling the servers and double check everything you want to do. Understand the potential benefits and drawbacks to your choices and actions before implementing them. This should become second nature to you during your new career.
But don't worry about breaking things. Worry about what you should do if you break things. Always have a plan in place.
I'd recommend reading a book like The Practice of System and Network Administration to get a general overview of what a system administration should look at and how one should approach the job.
Grab a copy of the Practice of system and network Administration as a basis to start from. Not a textbook, but covers a wide range of topics and key concepts that are not tied to a specific technology stack.
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
I haven't heard of any of these. Unless you're pressed for time, read one of the classic DS&A books, and then read some c++ stuff. There are lots of ds&a books that are partially or fully language agnostic, they only have code blocks in pseudocode. This provides a very important opportunity for you to implement stuff in whatever language you like. Here's the one I used in college: https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844/ref=zg_bs_132570011_2
I don't think it's reasonable to speak about "canon" books in computer science - the field has become so broad that a handful of PhDs in the modern era could get to the very bleeding edge of their niche and not share any crucial books in common among their libraries.
That said, here are a few I think are fantastic:
Among these, I think Stevens' UNPv1 is about the best textbook, by a lot, I've ever owned.
Clean Code
vs
Code Complete
> 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:
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
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!
The C Programming Language
> 3) is it hard to program your own apps? I know a bit
> about programming (limited experience in college).
> Would I be able to pick it up easily?
Don't see anyone answering this part of your question so I'll take a shot at it:
The Pebble is programmed in C, which is not the simplest language to learn, but it's certainly doable and once you master it you'll be in awe of what it can do. It's the programming language of choice for small footprint embedded systems, so you'll find this a useful skill in the long run, even if it's just to understand what others have to do to make your app a reality.
If you've never programmed in C it's probably best to get a book and start reading. I started with Kernighan & Ritchie's The C Programming Language -> and still feel it's the Bible from which all others are derived. Of course, if you under 25 and don't know what a book is, you can always hike off to the Google and start searching "C tutorial").
Pebble Central will provides you with an SDK with all the libraries you need to access Pebble features (e.g. User Interface, timers, comm to/from the watch, etc) but to make this work you'll also need a dev environment to hook all this up to your code.
The traditional/"hard" way to code for Pebble is to set up the Pebble dev environment on your computer and use command line tools to edit/build your app. For this you'll need a copy of the Pebble SDK and a Linux/MacOS machine Inexplicably, Pebble development is not currently supported under Windows, although if you're a real keener you can set up a virtual machine, install Linux and fake it. If you want to go this route, Google "Pebble Vagrant development" and click on the first link okay, if you're really lazy you can click here ->.
Note: I've tried the Vagrant/VirtualBox VM route - trust me, it's currently so poorly documented as to be a true pain in the ass. Not recommended if you can avoid it...
Which brings us to the other alternative. Katharine Berry, an MIT student who apparently dabbles in things Pebble in her spare time, has produced the site Cloudpebble.net ->. This is a fully integrated IDE, with GitHub support and built in SDK. This really does simplify the task of building Pebble Apps, although at the expense of some privacy, as your code lives on somebody else's server. This is no problem if you're developing open source apps or simply teaching yourself but would probably be an issue for commercial developers. Still, I can attest to how much easier it makes things if you're primary focus is on getting your first app done. I love it and recommend it highly.
Whichever approach you take, you'll find the Pebble Central developer site a useful place to hang out. It's got the online docs, links off to developer forums and more. [Pebble Developer Central is located here ->] (http://developer.getpebble.com/).
There are a few examples of programs out there you can use as tutorials and/or starting point for your own designs. I found Katharine Berry's peapod App (a music control app for iOS) to be a good starting point and her httpebble App is the definitive tool for accessing web resources. Her GitHub home is here
I've also written a couple of Pebble Apps and turned them lose under the MIT License (free for reuse if attribution is preserved). My Tempus Fugit App was (I believe) the first to provide multitasking capability, as well as stopwatch, timer a "meeting cost calculator" and multiple watchfaces all in a single app. Source code for this is available here I made an effort to comment the code to help folks figure out what's going on, so hopefully this will help you get started with your own app.
So that's a quick tour of what it takes to get started. Please feel free to post follow-up questions and I'll do what I can to fill in the missing bits...
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!
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.
Not game-specific, but these books are definitely industry essential books when it comes to anything related to software development.
In no particular order (though Code Complete should probably be first):
Code Complete and Pragmatic Programmer are great books about programming as a craft and are both language agnostic.
This is a pretty good book about design patterns.
https://www.amazon.com/Head-First-Design-Patterns-Brain-Friendly/dp/0596007124
The key to building bigger systems is writing modular code. I don't mean just code made of modules, I mean code in which the module boundaries are in the right places. Code divided into the most meaningful and distinct chunks.
You want to divide areas of responsibility into separate modules, in such a way that each module has a clear, distinct and succinct area of responsibility and the interfaces between modules (the function calls and data passed) are simple and minimal. Finding the right boundaries takes thinking deeply about the problem, and considering different ways to model it. When you get it right, you will find that changing implementation of one part of the code is much less likely to cascade into other areas.
The idea that this is an important way to think about designing a program is called the separation of concerns principle.
Patterns that can help with this include dependency injection which is often required for unit testing, and which forces you to separate modules and aspect oriented programming which deals with modularizing cross-cutting concerns, things like caching, logging and error handling which often show up in many different places in your code and undermine modularity.
Code Complete by Steve McConnell addresses these issues and has lots of helpful advice for dealing with large projects and large systems.
Anyone who likes this stuff should really read code. The author goes from tin-can phones to building a computer, in language anyone could follow.
Did you know Amazon will donate a portion of every purchase if you shop by going to smile.amazon.com instead? Over $50,000,000 has been raised for charity - all you need to do is change the URL!
Here are your smile-ified links:
https://smile.amazon.com/Code-Language-Computer-Hardware-Software/dp/0735611319
---
^^i'm ^^a ^^friendly&nbsp;bot
Three books I have been using:
The Definitive Guide to How Computers Do Math
Web page here: http://www.diycalculator.com/
Assembly Language Step-by-Step: Programming with Linux
Hacking: The Art of Exploitation, 2nd Edition
The first uses a virtual machine running on Windows, with 5 registers, 65K of virtual memory, a debugger, and will give you a good basic understanding of what is going on. The second book uses Intel X86 on Linux, and gives a solid foundation of the most used instructions. The third book is just good.
Other favorites of mine include "The Art of Debugging" by Norm Matloff (google for his excellent web page) and "Professional Assembly Language" by Richard Blum.
Have fun!
Gödel, Escher, Bach: An Eternal Golden Braid by Douglas R. Hofstadter is perhaps the most thought provoking book I have ever read. It unifies music, art, and mathematics and will simply blow your mind.
That's one of my favorite popular science books, so it's wonderful to hear you're getting so much out of it. It really is a fascinating topic, and it's sad that so many Christians close themselves off to it solely to protect their religious beliefs (though as you discovered, it's good for those religious beliefs that they do).
As a companion to the book you might enjoy the Stated Clearly series of videos, which break down evolution very simply (and they're made by an ex-Christian whose education about evolution was part of his reason for leaving the religion). You might also like Coyne's blog, though these days it's more about his personal views than it is about evolution (but some searching on the site will bring up interesting things he's written on a whole host of religious topics from Adam and Eve to "ground of being" theology). He does also have another book you might like (Faith Versus Fact: Why Science and Religion are Incompatible), though I only read part of it since I was familiar with much of it from his blog.
> If you guys have any other book recommendations along these lines, I'm all ears!
You should definitely read The Selfish Gene by Richard Dawkins, if only because it's a classic (and widely misrepresented/misunderstood). A little farther afield, one of my favorite popular science books of all time is The Language Instinct by Steven Pinker, which looks at human language as an evolved ability. Pinker's primary area of academic expertise is child language acquisition, so he's the most in his element in that book.
If you're interested in neuroscience and the brain you could read How the Mind Works (also by Pinker) or The Tell-Tale Brain by V. S. Ramachandran, both of which are wide-ranging and accessibly written. I'd also recommend Thinking, Fast and Slow by psychologist Daniel Kahneman. Evolution gets a lot of attention in ex-Christian circles, but books like these are highly underrated as antidotes to Christian indoctrination -- nothing cures magical thinking about the "soul", consciousness and so on as much as learning how the brain and the mind actually work.
If you're interested in more general/philosophical works that touch on similar themes, Douglas R. Hofstadter's Gödel, Escher, Bach made a huge impression on me (years ago). You might also like The Mind's I by Hofstadter and Daniel Dennett, which is a collection of philosophical essays along with commentaries. Books like these will get you thinking about the true mysteries of life, the universe and everything -- the kind of mysteries that have such sterile and unsatisfying "answers" within Christianity and other mythologies.
Don't worry about the past -- just be happy you're learning about all of this now. You've got plenty of life ahead of you to make up for any lost time. Have fun!
Computer scientist here... I'm not a "real" mathematician but I do have a good bit of education and practical experience with some specific fields of like probability, information theory, statistics, logic, combinatorics, and set theory. The vast majority of mathematics, though, I'm only interested in as a hobby. I've never gone much beyond calculus in the standard track of math education, so I to enjoy reading "layman's terms" material about math. Here's some stuff I've enjoyed.
Fermat's Enigma This book covers the history of a famous problem that looks very simple, yet it took several hundred years to resolve. In so doing it gives layman's terms overviews of many mathematical concepts in a manner very similar to jfredett here. It's very readable, and for me at least, it also made the study of mathematics feel even more like an exciting search for beautiful, profound truth.
Logicomix: An Epic Search for Truth I've been told this book contains some inaccuracies, but I'm including it because I think it's such a cool idea. It's a graphic novelization (seriously, a graphic novel about a logician) of the life of Bertrand Russell, who was deeply involved in some of the last great ideas before Godel's Incompleteness Theorem came along and changed everything. This isn't as much about the math as it is about the people, but I still found it enjoyable when I read it a few years ago, and it helped spark my own interest in mathematics.
Lots of people also love Godel Escher Bach. I haven't read it yet so I can't really comment on it, but it seems to be a common element of everybody's favorite books about math.
An alternative to the gang of 4 book which is easier to digest is the head first guide
Head First Design Patterns https://www.amazon.co.uk/dp/0596007124/ref=cm_sw_r_cp_apa_i_jGIzDb57C3ACR
I suggest this book, Code Complete. It has nothing to do with Python and it's pretty old at this point but by reading it, I know for a fact that it has a lot of the same ideals. knowledge, values and tips that my college teachers tried very hard to impose upon me in what is considered one of the best IT college courses in my country https://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670
You can also procure your HR department (or your boss) and share the situation. Tell them you'd like to enroll in some courses to get up-to-speed with everyone else around you, since you don't have the same training as them. Most companies (or at least a lot of them) will offer to pay the entire thing for you too.
If you haven't read it, I recommend Code Complete. It's a classic for a reason.
You read code far more than you write it, so do whatever you think is necessary to make the code more readable. You seem to be beyond the basics (self-documenting code, etc), so a few advanced tips:
There are a lot of good practices such as encapsulation, information hiding, and idempotence, that are too in-depth to get into here. IMO, GameMaker makes it really hard to follow some of these good practices, so I hope these suggestions are helpful to you.
One thing good to learn is social engineering, as its one of the most common threats faced by basically everyone. If you learn how malicious social engineers think (and how they combine knowledge with tech based hacking), you can defend against them better. I enjoyed Unmasking the Social Engineer.
Also, if you're not experienced with low level systems, you should read The Art of Exploitation.
This is a really great book about the topic. It's much simpler than you might think but kind of tricky to explain unless you know a bit of back ground. The book costs less than a tenner and will give you a while different appreciation of how computers work. Well worth a read even if it starts out seeing rather simple.
https://www.amazon.co.uk/Code-Language-Computer-Hardware-Software/dp/0735611319
Are you an experienced programmer already? If so, Javascript the good parts. http://www.amazon.com/JavaScript-Good-Parts-Douglas-Crockford/dp/0596517742/ref=sr_1_1?ie=UTF8&amp;s=books&amp;qid=1251072337&amp;sr=8-1
here you go
It's the 'hidden language', not 'secret'. Sorry about that.
This book is a very good explanation of how computers work. It starts with explaining electromechanical switches, and how you can turn a couple switches into a logic gate. Then, it shows how you can put logic gates together to do arithmetic. It goes on like that until you reach programmable computers.
Hooray, a question I can answer!
One of the problems here is that the question is worded backwards. Binary doesn't combine to give us programming languages. So the answer to your question is somewhat to the contrary: programming languages were invented to ease the tedium of interfacing using binary codes. (Though it was still arguably tedious to work on e.g. punched cards.) Early interfaces to programming machines in binary took the form of "front panels" with switches, where a user would program one or several instructions at a time (depending on the complexity of the machine and the front panel interface), using the switches to signify the actual binary representation for the processor functions they desired to write.
Understanding how this works requires a deeper understanding of processors and computer design. I will only give a very high level overview of this (and others have discussed it briefly), but you can find a much more layperson accessible explanation in the wonderful book Code: The Hidden Language of Hardware and Software. This book explains Boolean logic, logic gates, arithmetic logic units (ALUs) and more, in a very accessible way.
Basically, logic gates can be combined in a number of ways to create different "components" of a computer, but in the field of programming languages, we're really talking about the CPU, which allows us to run code to interface with the other components in the system. Each implementation of a processor has a different set of instructions, known as its machine code. This code, at its most basic level, is a series of "on" or "off" electrical events (in reality, it is not "on" and "off" but high and low voltages). Thus, different combinations of voltages instruct a CPU to do different things, depending on its implementation. This is why some of the earliest computers had switch-interfaces on the front panel: you were directly controlling the flow of electricity into memory, and then telling the processor to start executing those codes by "reading" from the memory.
It's not hard to see how programming like this would be tedious. One could easily write a book to configure a machine to solve a simple problem, and someone reading that book could easily input the code improperly.
So eventually as interfacing with the machine became easier, we got other ways of programming them. What is commonly referred to as "assembly language" or "assembler" is a processor-specific language that contains mnemonics for every binary sequence the processor can execute. In an assembly language, there is a 1:1 correlation between what is coded, and what the processor actually executes. This was far easier than programming with flip-switches (or even by writing the binary code by hand), because it is much easier for a human to remember mnemonics and word-like constructs than it is to associate numbers with these concepts.
Still, programming in assembly languages can be difficult. You have to know a lot about the processor. You need to know what side-effects a particular instruction has. You don't have easy access to constructs like loops. You can't easily work with complex datatypes that are simply explained in other languages -- you are working directly with the processor and the attached memory. So other languages have been invented to make this easier. One of the most famous of these languages, a language called "C," presents a very small core language -- so it is relatively easy to learn -- but allows you to express concepts that are quite tedious to express in assembler. As time has gone on, computers have obviously become much faster, and we've created and embraced many languages that further and further abstract any knowledge about the hardware they are running on. Indeed, many modern languages are not compiled to machine code, but instead are interpreted by a compiled binary.
The trend here tends to be making it easier for people to come into the field and get things done fast. Early programming was hard, tedious. Programming today can be very simple, fun and rewarding. But these languages didn't spring out of binary code: they were developed specifically to avoid it.
TL;DR: People keep inventing programming languages because they think programming certain things in other ones is too hard.
https://www.amazon.com/Code-Language-Computer-Hardware-Software/dp/0735611319/ref=mp_s_a_1_1
This book explains how computers work from first principles (electricity and switches on up). Very easy to read. I am surprised it hasn’t been mentioned yet.
Learning electronics is a lot like music. There is an insane amount of information, but if you get an economic working knowledge under your belt, you can really do some amazing things. In order for you not to get lost in the rabbit hole, I will provide you these methods of learning practical hobby electronics.
First, is simply just a suggestion. There are two "domains" of electronic thinking and analysis: digital and analogue. Fuck analog right in its dumb face. The math used in analog is fucking super duper hard, and analog circuits are prone to interference problems. Digital is where you want to be. It's vastly simpler to use programmable digital parts, and analyze digital circuits. Don't get lost in AC equations of capacitor, or the god damned transistor equation (seriously, fuck that. )
Okay here is how I learned hobby digital electronics:
First buy this, and go through all the examples in the workbooks. When you learn electronics you 100% HAVE TO DO HANDS ON LEARNING! DONT LEARN IT FROM A BOOK! MAKE CIRCUITS!
https://www.amazon.com/Radio-Shack-Electronics-Learning-20-055/dp/B00GYYEL8I
At the same time, read this (which is a good topical explanation, and free):
http://jacquesricher.com/NEETS/
And buy and read this (which is an EXCELLENT formal introduction into the physics):
https://www.amazon.com/Practical-Electronics-Inventors-Third-Scherz/dp/0071771336
Also you are going to learn how to program, which is an entirely different topic. Programming and hobby electronics make you a master of the universe, so it's worth it. I learned programming in the electronics domain and it was awesome. I made a microcontroller FM synthesizer:
https://www.youtube.com/watch?v=3TvuzTK3Dzk
So basically, the way I learned programming in general was self-teaching with books. Again, you have to do it hands-on. Actually complete the examples in the books, and you'll be fine.
First, learn procedural c programming using C primer plus. Buy an older version so it'll be super cheap:
https://www.amazon.com/gp/offer-listing/0672326965/ref=sr_1_3_twi_pap_1_olp?s=books&amp;ie=UTF8&amp;qid=1465827790&amp;sr=1-3&amp;keywords=c+primer+plus
Next, learn Object oriented programming using head first java. They do a great job of tackling OOP, which can be a difficult thing to learn.
https://www.amazon.com/Head-First-Java-Kathy-Sierra/dp/0596009208/ref=sr_1_1?s=books&amp;ie=UTF8&amp;qid=1465827860&amp;sr=1-1&amp;keywords=head+first+java
You're overwhelmed because they're deep topics. But, seriously, its the most fun shit ever. You'll love learning how to do it.
> Look for a book on object oriented programming
For this I recommend both Head First Java and then follow that up with Head First Design Patterns.
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
One of the best ways to learn is by studying other people's code. Using book references like the one you have on C# is a great start. Make sure you ask questions to yourself and really study the code. Questions to keep in mind: why is this line before that line? What would happen if these two lines were swapped? How could I make this easier to read? Do all of these lines make sense when grouped together in a function? How can I break this down into a simpler class/object?
Those are the kinds of questions professional developers ask themselves on a daily basis. If you start asking yourself those kinds of questions early, you'll become a very competent programmer.
I highly recommend new programmers to read Code Complete: http://www.amazon.com/dp/0735619670/ref=cm_sw_r_tw_awdm_ZlAbvb1GP04MC
The fact that you've submitted this question indicates that you're on the right track. You just need practice.
I generally agree, but the problem with patterns is some folks try to shoehorn everything into a pattern sometimes turning something simple into something more complex than it needs to be.
&#x200B;
I find that following SOLID with YAGNI at the back of your mind tends to be what seems to work best for me
Along the lines of patterns: I'd recommend Head First Design Patterns
These are great suggestions. The three books I typically give devs early (that fit in well with the two presented here) are:
Refactoring by Martin Fowler
This is a list of patterns of common refactoring a and how to do them safely. It’ll help you recognize transforms you need to make in your code as it changes.
The Pragmatic Programmer by Dave Thomas and Andy Hunt
This is a great guidebook for how to get better at being a software engineer. Essential read.
And while there are lots of options for design patterns books...
Head First Design Patterns was the one that helped me internalize them. Even if you aren’t writing much (or any) Java, the method of teaching is hugely valuable.
Yes, there is also Head First Design Patterns which is also very good.
Code is an absolute classic.
If you're interested in reading up on this, I highly recommend https://www.amazon.com/Code-Language-Computer-Hardware-Software/dp/0735611319
Or for a more hands-on approach: https://www.amazon.com/Elements-Computing-Systems-Building-Principles/dp/0262640686/
This is kind of a weird one but I’d suggest Code. Very non-technical, no programming, but cool history and fundamentals.
Code: The Hidden Language of Computer Hardware and Software - Code: The Hidden Language of Computer Hardware and Software https://www.amazon.com/dp/0735611319/ref=cm_sw_r_cp_api_i_IiH2DbWSNWHMW
This is the book you want to read. It walks you through every bit of how a CPU works, in an incredibly approachable way. (If you can understand a light switch, you can understand this book.)
I'll recommend Code, even though it isn't specifically theoretical. However, it does go over how code (semaphore, morse code) evolved over time. From someone who does program this is about a 'human' a book as they come which could fit exactly what you are looking for.
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.
https://www.amazon.com/Hacking-Art-Exploitation-Jon-Erickson/dp/1593271441
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.
Read this book: Gödel, Escher, Bach: An Eternal Golden Braid at least 3 times, and take your time.
For some physics :
Penrose - Road to Reality
Gleick - Chaos
Some math/philosophy :
Hofstadter - Godel, Escher, Bach: An Eternal Golden Braid
Anything early by Dawkins if you want to avoid the atheist stuff though his latest is good too.
Anything by Robert Wright for the evolution of human morality.
Pinker for language and the Mind.
Matt Ridley for more biology.
Here's some lighter reading I've liked:
Readable, but more hardcore
Hardware:
Mathy:
Programmy:
Unixy:
Off the wall:
Introduction to Algorithms is probably the best book if you want to go deep in algorithms eventually.
Cracking the coding interview book is also a great repository of "must-have" concepts for CS.
Introduction to Algorithms, 3rd Edition
Surprised no one mentioned this one. This book goes into more depth on the topic, including theory and derivations of formulas.
Its definitely one of the best Algorithm books out there.
I would also look into Coursera, specifically Stanford's algorithm design class, it uses the above textbook and goes into more of the design of algorithms vs. here is how they work.
Did you read any mathematical papers, are you familiar with university-level math, or with computer science?
What might help you get familiar with this style of writing is Concrete Mathematics ( https://notendur.hi.is/pgg/(ebook-pdf)%20-%20Mathematics%20-%20Concrete%20Mathematics.pdf ), or Introduction to Algorithms by Cormen ( http://www.amazon.com/dp/0262033844?tag=top-books-cs-20 ).
The first book is more about math, but it's a nice and fun read. And it will make you familiar with math notations. The other book is about algorithms and data structures - difficult to read, but once you get through the first chapters, reading things the Yellow Paper should be much easier. Protip with Cormen - skip the proofs at first :)
Most developers, even the ones familiar with architecture and design patterns, aren't familiar with the theoretical/mathematical groundwork behind all this.
In other words: the paper is written for computer scientists, not developers really. Many excellent developers are shit computer scientists and vice versa.
C and C++ are pretty different nowadays depending on your standard. "Game engine" is a pretty generic descriptor, because you can build game engines in a lot of different ways depending on your needs for the genre and how all-encompassing your engine needs to be, so I'm going to ask you a few questions about specifics in regards to your experience which might help to flesh out where you can start your search.
Hope this helps.
My suggestion is always to start with Python. It's a very high level language and it's very easy to learn. In fact, Python recently became the most popular language to teach beginners. I know you wanted to learn Java, but there are several things about it that make it not so great for beginners, as well as several things about Python that make it good for beginners (ask why if you're interested, but it may be a bit technical). As a programmer, you will likely learn a dozen or more languages (I've learned over a dozen in school), so saving Java for a bit later isn't really an issue. You'll find in programming that a lot of the important things apply to most languages, so learning these allow you to apply them to new languages quite easily. My university now uses this book in the first year computer science courses.
Get yourself situated with a free GitHub account. GitHub is my favourite version control. If you have a student email you can get a free private repository (so others can't see your stuff). If you don't have a student email to use to get one, you can still make a free account, but it will be public. What that means is that anyone who navigates to your account can see all your code. Since you're just starting out, it shouldn't matter if people browse your code, there's not much to see since it's just you going through the basics. GitHub has a tutorial for new users and also has a user-friendly client that makes it all really simple. You can save the more complex stuff for later until you're comfortable.
Once you've gone through Python and learned a bit, it's time to get into some of the language-independent things. Introduction to Algorithms is an amazing textbook. The authors are some of the most well respected people in the field and I've used it in school in more than one course. You can go through this at any time. I recommend you programming some of the things (they provide some code as well), and perhaps trying this stuff in Java might be a good segway from Python to Java.
Designing for the web? First thing to do is read "Don't make me think." It's a thin book you should be able to knock it out in no time.
If you are coming from a print world remember CMYK and inches mean nothing, this world is RGB and Hex colors and pixels. Telling the web guy you want a 15% tint of a Hex color isn't helpful.
Be aware the site, text and text flow will look slightly different depending on the browser and platform. How the page, text and forms look on a Mac in Safari is not the same as a PC with IE7 (or 8 or 9) or a mobile device. Your careful word wrap and precise leading is going to be lost.
Map out the likely clients who are the target of the website and their likely viewing device and browsers. Design for those first. If you are designing a site targeting corporations chances are the viewing will be on a PC with some version of IE. If you are designing a site for photographers targeting designers and ad agencies then a Mac with Safari or FF is your most likely target. If most of your viewers are going to be on laptops or mobile devices keep that in mind first.
Include a Photoshop page with all the main colors used. Text color(s), link colors (link, visited, hover and active colors) and all other colors (background, page, dividers, etc.) that will be showing up.
Finally, online is not like working in InDesign, Quark, Illustrator or even Photoshop. Approve everything at 100% size. Just because the vector files, and 6 point type, look great at 1200% in Illustrator doesn't mean they will translate to 72 ppi in a browser.
Other than that, what everyone else said.
Knowing a giant list of programming languages is really overrated. Instead, focus on learning new programming concepts.
Sometimes that can mean learning a new language, but not always. Some examples:
And regarding your concern of it being harder to learn new languages later, you'll only really have that problem when learning a vastly different language (such as Scheme when compared to your C#). Once you know one language in the same "family", a lot of knowledge carries over.
Actually, it's a bit of both.
Problems / Criticism of GoF
1. The GoF was written in the era of "OOP is a silver bullet" and single-threaded programs by academics who were generally clueless about the importance of understanding data transforms, data caches, instruction caches, and minimizing cache misses. See: Pitfalls of Object Oriented Programming of how you get massive speedups just by understanding cache usage and re-arranging the data.
2. One of the problem with the GoF methodology is when people turn it into a religion. People start trying to apply design patterns to everything even when it isn't needed and you end up with this over-engineered, bloated, slow, clusterfuck of code.
3. Programmers who focus on performance have also been pretty vocal about "cargo cult programming" and design patterns:
> The “Design Patterns” book is one of the worst programming books ever. Yes, really. I’m 100% dead serious when I say that I think it has set (and will continue to set) the progress of software development back by decades. Why?! Let me offer up a parable; I will call it “The Plank.”
> "Design patterns are spoonfed material for brainless programmers incapable of independent thought, who will be resolved to producing code as mediocre as the design patterns they use to create it with."
4. While abstraction can be a nice way to solve a problem there are ALWAYS trade-offs. The flexibility of abstraction is that you generally tend to lose efficiency. Blinding applying a design pattern means you aren't thinking about the performance issues. In today's age of multi-core software this is a huge disadvantage compared to your competitors.
And while Ericson and Acton tend to throw the baby out with the bathwater they are speaking from years of experience of writing fast, simple code. This ISN'T an appeal to authority as they aren't just some armchair academics -- they have demonstrated they have understand HOW to write FAST code. Their experience also matches what I've seen.
5. Another problem is that changing the hardware changes the problem. GoF doesn't take this into account.
6. Very rarely does OOP "perfectly" model the problem. GoF ignores this.
7. Another part of the problem is that OOP is NOT scalable. OOP has a design fallacy that "one is the common case." This is almost never the case. The common case is usually you have multiple objects. Again GoF ignores for the most part. They take a stab at it with the
Flyweight Design Patternbut that isn't scale when you REALLY do have many, mutable objects such as the particles of a particle system.And while I am not as adamant as Ericson or Acton about being "anti-design-patterns" they DO have a point -- not understanding the strengths AND weaknesses of an algorithm makes for a poor programmer IMHO. Remember, there are THREE ways to optimize:
O(n)algorithmGo ahead and use design patterns for your tools. But for engine/games DoD will usually solve the problem simple and faster then misapplying and blindly applying a design pattern.
Solution
Lastly the problem of complexity was summarized by Fred Brooks in The Mythical Man-Month
> "Show me your flowcharts (source code), and conceal your tables (domain model), and I shall continue to be mystified;
> show me your tables (domain model) and I won't usually need your flowcharts (source code): they'll be obvious."
A more modern colloquialism would read:
> Show me your code and I'll have to see your data,
> Show me your data and I won't have to see your code.
The secret to high performance is NOT the algorithm but to focuse on HOW the data is transformed. i.e. The first rule of optimization is:
Know Thy Data
It depends on how much programming experience you have. If FreeCodeCamp is all you've done and have only worked with JavaScript, then I think that CS50 would be worth going through. For the first few lectures, he goes material which uses C and talks about low-level memory management and how many things work under the hood. While this isn't necessary to the daily work of a web developer, it is still good to write code while being conscious of what's happening under the hood through all those abstractions.
As /u/artotal said in his reply, learning the fundamentals of data structures and basic algorithms and complexity really go a long way. I don't think CS50 goes very in-depth with regards to this, but there's a few different sources you could learn from. You could go the hands-on route and hop straight onto sites like HackerRank and Kattis and start working your way up the problem ladders if you already have some basic familiarity. If learning from scratch, FreeCodeCamp has a nice set of videos on their YouTube channel talking about different data structures implemented in JS.
As for general progression after FreeCodeCamp, keep building projects. I'm not sure how far you're into the curriculum, but it's quite long and it's got many projects even in the curriculum if you do both front and back end curriculums. With your currently existing projects, go back and see if you can make improvements to any of them. Maybe try and move them off of Codepen (if you did them there) and to your own personal portfolio site. Refine your portfolio page and have links to your projects, your Github, resume, etc. You can have free hosting through Github Pages and you should be able to host all the front end projects there. For Node projects, you can try hosting them through Heroku, or see about free hosting through Google Cloud or get trial credits on AWS or Digital Ocean.
I hope this gave you a general idea of how to progress. Choose what you want to do depending on your immediate goal. Looking for a job? Polish that resume, get your portfolio site and projects up and running, maybe get a domain name for it. Go on HackerRank and LeetCode and practice some common interview problems. Have a bit of free learning time? Dive into the fundamentals of CS. Consider taking a look at some of the tried and true CS textbooks like this one (I'm sure that with some Googling you can find links to a pdf of it for free).
That being said, some websites simply aren't going to be enough. Codeacademy is awesome, but don't expect to learn algorithms from it; you probably would want to pick up a copy of CLRS and do the MIT course
This is by far my favorite book. I liked it so much I have the first and second edition.
http://www.amazon.com/Practice-System-Network-Administration-Edition/dp/0321492668
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...
I liked "Don't Make Me Think" for basic user experience and layout stuff. It's mostly about web design, but it can definitely apply elsewhere.
As a person with no education beyond high school, take all that I say with a grain of salt. I'm a pretty successful web designer and front-end developer, having working with four startups and done a year of freelancing.
It is not uncommon to hear industry peers criticize the education system as it pertains to web design because often the practices you learn are no longer the standard or relevant. I've heard of many stories where designers exit college (with no working experience, obviously) and have an incredibly difficult time finding work for the reasons I listed above.
Education has never been brought up at any of the companies I've worked or those that I've consulted with. I believe the reason for this is that I have a body of work to show along with whatever reputation I've garnered on Dribbble, say.
All this being said, it is entirely possible for you to develop your skills on your own, such as I did, and find work. I'm happy to list all the reading materials that I own that helped me get where I am now. I'll list what I remember but I'll have to go check when I can get a second:
Hardboiled Web Design
HTML5 for Web Designers
CSS3 for Web Designers
The Elements of Content Strategy
Responsive Web Design
Designing for Emotion
Design is a Job
Mobile First
The Visual Display of Quantitative Information
The Elements of Typographic Style
Thinking with Type
The Icon Handbook
Don't Make Me Think
If you invest your money in those and actually read them, you will be well on your way. Feel free to ping me. Good luck!
I think the book people normally recommend for this is Effective Java by Joshua Bloch
Read this and make a task and project list
Aside from that I work at an MSP and quite enjoy my workload but no 2 days are the same.
A lot of what has been suggested is great for learning linux. Realize that "out there" very little is served out of a single box (and if it is you're doin it wrong). Production infrastructure likely looks and acts very very differently from your home linux workstation. Just because you know how to type
sudo apt-get install apache2does not mean you are ready for a full ops position... BUT - if you put in the wrench time and pay your dues, you will get there.Here are some areas that would be good to build your knoweldgebase up in...
So off the top of my head there's a bunch of things you could study. I think that's quite a bit to get your head around, and a deep understanding of some of these topics will only come from working experience. There may be a LOT of work to do in some of those areas. Getting a fully functional xen (or kvm) based system up and on it's legs is not an easy task for the uninitiated. It is my opinion (and everyone else is free to disagree with me) that all good sysadmins/ops/engineers need to "grow up" in some area of lower level technical position. That can be a jr. admin position, the helldesk, or whatever else... This will give you the "systems" working experience that will let you branch into a full fledged admin/op position. Getting some certs under your belt can help you get in the door, but by all means isn't required. Cert's cost money and (the ones worth getting) take time. Personally, I tend to stray away from places that make a big deal out of certs... but that's just me.
tl;dr: Learn how to learn. Pick something you don't know how to do and leverage a linux system to accomplish that goal - rinse and repeat.
When I have time to pick new projects, I just pick up the bible and start reading until I have my next project.
People might argue that you really don't need to learn C. They are lying to you. Go buy this read it over the summer, it will do nothing but help you with anything else you ever decide to code in even if you never touch C again.
http://www.amazon.com/C-Programming-Language-2nd-Edition/dp/0131103628
As someone who also has been looking to delve deeper into C for a better understanding of the language and programming in general, I would recommend The C Programming Language, 2nd Edition by Kernighan and Ritchie.
https://www.amazon.com/Programming-Language-Brian-W-Kernighan/dp/0131103628
While it's not a huge tome of a book, the amount of material and exercises is invaluable, and I've learned more in the first 15-20 pages than I've learned googling or from other resources in the last several months. For 35 bucks new, this book is worth it, although it's even cheaper if you rent or buy it used.
If you already have an engineering degree then you already know how to study. What experience do you have with embedded? If you don't have any then you should be sure it's what you want before you commit to anything huge.
I think the best way to get a job in embedded systems is to build embedded systems, and not bother with language certifcations. I might be going against the grain here a bit but I would suggest starting to dip your toes into embedded systems by buying an arduino and messing around with it.
Arduino gets a lot of flack for being "not real" embedded systems, and while it's true nobody is going to hire you because you can make an impressive arduino project, IMHO it's a great introduction to what embedded is about. The hardware equivalent of "hello world" is blinking an LED. If you are serious about learning then you will quickly outgrow the arduino, but you can always throw away the bootloader and try to program the ATmega with bare metal gcc and avrdude.
I don't know what you already know nor how you feel about math, but things you will want to learn include:
If you get this far and still want to become an embedded systems engineer then you're doing pretty well. I would say just try to build projects that utilize these skills. Maybe you can use your mech background to build a robot and then design the software to support it. Get used to reading datasheets for parts, and imagining what the digital logic inside looks like. Get used to searching google for answers to your questions.
C is good to learn as a beginner, although it is an unforgiving language. If you can write C, you will be able to learn the vast majority of other programming languages in common use today with a very small learning curve.
Any CS department worth anything is going to have you write in low level languages at some point, especially C and assembly.
To get started, you're going to need a good C compiler - I recommend GCC. The C Programming Language is also a priceless resource for anybody interested in learning C. Finally, although this is optional, you should learn to use a "serious" text editor, such as emacs or vim.
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.
Android is java, there is 100 million devices right there.
I know Java, along with a handful of other languages used on the JVM (kotlin, scala). I also use Python quite a bit, C++/ObjC (though I use it much less), and I dabble in JS if needed. I've written perl, php, pascal just to new a few others. Once you learn the fundamentals of CS, you should be able to grasp any C like language pretty quickly. (even C++ if you just keep it simple)
What you should focus on is learning object orientation. Relationships between different objects/classes, their interfaces, and how to actually construct software. Don't worry about language so much yet, you will quickly get the point where you know 5+ languages.
Now go read this book.
https://www.amazon.com/Pragmatic-Programmer-Journeyman-Master/dp/020161622X
Also, I have to say that knowing Java and Python is a sought after combination.
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.
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
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.
If you've never programmed anything before and you really want to learn coding (if it's your priority) instead of rushing out your first game, I think LÖVE is pretty great for that. You get to learn Lua and an awesome framework. There's also Phaser, which you can learn JavaScript or its variants with it. JavaScript is probably more widely used than Lua because of the World Wide Web.
And when you're done with those, you can try to learn Java and use libGDX, or C# and Unity.
GameFromScratch.com has plenty of tutorials to get you started.
When you've decided you want to be an ultra low-level programmer, buy The C Programming Language. Learn the basics of C, and then follow Handmade Hero.
When you're done with that you're probably on your way to become a godly programmer. You'll probably know how to do some assembly and machine code by then.
But first, you're gonna need lots of discipline to even get to anywhere.
There are no shortcuts.
If you just want to make a game, however, GameMaker and Construct 2 are pretty awesome!
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'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)
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.
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
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
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 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.
You probably already have, but if not, definitely read Design Patterns, which is old but a classic. I'd also highly recommend the Pragmatic Programmer.
EDIT: I just want to say, that I also fully support alienangel2's answer. I wanted to recommend a couple good books to get you on "the path", but ultimately, the best thing by far is to find a job that grows you. For some people, the best way to do that is to work at a super small startup, where everything you're building is from scratch. For others (like me), the best way is to work at a company with tons of really smart people who have already built great software, and learning from them and the choices they've made (and why). And if you still feel like you're regressing since school, maybe that's the answer: go back to school (i.e. get a Master's or PhD)!
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.
Pragmatic Programmer is over a decade old, but I doubt you'll more useful advice.
I agree that Code Complete is an excellent book. Another I'd add to the list is The Pragmatic Programmer.
Effective Java is good but it's really about the nuances of the Java language. It looks like you are looking for better programming practices in general. If so I'd go with the books already mentioned.
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/).
K&R is the book for C, especially if you have prior programming experience.
Il mondo della programmazione è incredibilmente vario, ti consiglio di cominciare con qualcosa che stuzzichi la tua voglia di fare, potrebbero essere le applicazioni web, oppure sviluppare su android o iphone, come la programmazione di videogiochi oppure realizzare un programma per windows o per linux.
Una volta capito cosa ti piacerebbe provare indirizzati su qualche tutorial veramente basilare, e impara facendo.
Se dovessi indicarti un linguaggio da cui cominciare non avrei dubbi: il C.
Non C++ mi raccomando ma il C puro.
Esistono diversi testi incredibilmente validi e oltre alla Bibbia ti consiglio di farti un giro su amazon per cercare qualche introduzione a qualche argomento o linguaggio specifico, tipo "coding for dummies" ecco.
Il python potrebbe essere un linguaggio buono per cominciare a capire, oppure il javascript a livello base.
Quindi in sostanza io ti consiglio di seguire due strade parallele allo stesso tempo, da una parte di fai un pò di culo con le basi, quindi imparando il C, dall'altra puoi divertirti a sperimentare con le tecnologie più recenti. Ad esempio su codeacademy puoi già cominciare a fare pratica di javascript (penso ci siano altri linguaggi disponibili).
Gli argomenti base che dovresti cominciare a studiare riguardano la programmazione procedurale ad oggetti.
Esistono altri paradigmi di programmazione come ad esempio quella funzionale ma al momento lasciala pure stare.
Ovviamente tutto in inglese, mi raccomando.
La plupart des formations t'apprendront rien d'utile mais prendront volontiers tes thunes.
Sinon t'as le CNAM, c'est bien, si tu veux à tout prix un vrai diplôme (ça aide à trouver le premier taff).
Tu peux aussi faire ça en solo :
Bref si tu fais rien que la moitié de ce qu'il y a dans la liste t'es facilement employable comme admin sys en apprenant quelques bases des réseaux . Avec python et de la virtualisation en plus t'es en chemin pour devenir devops (l'un des profils les plus recherché sur le marché).
En plus tu seras plus compétent que la majorité des bonhommes sortis de formations privées à la noix.
Introduction to Algorithms by CLRS
TAOCP is a waste of time and money; it's more for adorning your bookshelf than for actually reading. Pretty much anyone who suggests TAOCP and is less than 55 years old is just parroting Standard Wisdom™.
Godel, Escher, Bach is a nice book, but it's not as intellectually deep in today's world as it was when first published; a lot of the memes in GEB have been thoroughly absorbed into nerd culture at this point and the book should be enjoyed more as a work of art than expecting it to be particularly informative (IMO).
If you're interested in compilers, I recommend Engineering a Compiler by Cooper & Torczon. Same thing as TAOCP applies to people who suggest the Dragon Book. The Dragon Book is still good, but it focuses too much on parser generators and doesn't really cover enough of the other modern good stuff. (Yes, even the new edition.)
As far as real programming goes, K&R's The C Programming Language is still unmatched for its quality of exposition and brevity, but these days I'd strongly suggest picking up some Python or something before diving into C. And as a practical matter, I'd suggest learning some C++ from Koenig & Moo's Accelerated C++ before learning straight C.
Sipser's Introduction to the Theory of Computation is a good theory book, but I'd really suggest getting CLRS before Sipser. CLRS is way more interesting IMHO.
Good news is you have previous experience and C is a very simple language.
Learn C The Hard Way has some weird shit in it (wtf does "make is your Python now" even supposed to mean?) but it is largely good and do tend to recommend it despite the warts.
Really though, why not go straight to the source?
Just make sure you master pointers. It is really useful to understand what memory is on a physical or near physical level to understand pointers. It is one of those concepts that makes instant sense if you come from a hardware point of view, but can trip up newbies with a software point of view.
Read the sidebar.
If you haven't had programming knowledge before, then The C Programming Language by Dennis M. Ritchie and Brian W. Kernighan is right up your alley.
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.
Clean code. read it learn it love it
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.
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.
Against The God: the remarkable story of Risk- Outlines the history of probability theory and risk assessment through the centuries
https://www.amazon.com/Against-Gods-Remarkable-Story-Risk/dp/0471295639/ref=sr_1_1?s=books&amp;ie=UTF8&amp;qid=1475105434&amp;sr=1-1&amp;keywords=against+the+gods
When Genius Failed - A narrative of the spectacular fall of Long Term Capital Management, a hedge fund which had on its board both Myron Scholes AND Robert Merton (you will recall them from MFE)
https://www.amazon.com/When-Genius-Failed-Long-Term-Management/dp/0375758259/ref=sr_1_1?s=books&amp;ie=UTF8&amp;qid=1475105453&amp;sr=1-1&amp;keywords=when+genius+failed
Black Swan/ Antifragility- A former quant discusses the nature of risk in these controversial and philosophical books. Some parts of this book are actually called out and shamed in McDonald's Derivative Markets, one or the both of them are worth reading
https://www.amazon.com/Black-Swan-Improbable-Robustness-Fragility/dp/081297381X/ref=sr_1_1?s=books&amp;ie=UTF8&amp;qid=1475105478&amp;sr=1-1&amp;keywords=black+swan
Godel, Escher, Bach- Very dense look into recursive patterns in mathematics and the arts. While not actuarial, it's obviously very mathematical, a must read.
https://www.amazon.com/G%C3%B6del-Escher-Bach-Eternal-Golden/dp/0465026567/ref=sr_1_1?s=books&amp;ie=UTF8&amp;qid=1475105497&amp;sr=1-1&amp;keywords=geb
Endurance- This was recommended to me by a pure mathematics professor. Again, not actuarial, but more about the nature of perseverance though problem solving(sound familiar). It's about Shakleton's famous voyage to the south pole.
https://www.amazon.com/Endurance-Shackletons-Incredible-Alfred-Lansing/dp/0465062881/ref=sr_1_1?s=books&amp;ie=UTF8&amp;qid=1475105520&amp;sr=1-1&amp;keywords=endurance+shackleton%27s+incredible+voyage
I get teased by people that I am one of only 3 people in the world to have actually finished this book, one of those being the author and the other being the person who recommended to me, but Godel, Escher, Bach: An Eternal Golden Braid was pretty interesting. It covers the profoundness of the topic and is interspersed with Alice in wonderland style dialog that comes at the topic from another angle. Deep but captivating overall.
On a tangent, Goedel's theorem and Turing's incompleteness theorem, along with some other mathematicians who have gazed out over the edge of logic and gone somewhat mad are covered in the BBC documentary Dangerous Knowledge.
Gödel, Escher, Bach: An Eternal Golden Braid by Douglas Hofstadter
Head First Design Patterns: A Brain-Friendly Guide
A relatively unique methodology of approaching design patterns (using Java examples). Understanding design patterns will transform both you and your code.
EDIT: Adding my comment below to my comment here for better visibility and description of the book:
> It can absolutely be read as an introductory book! I would recommend going into the book having a foundation in an OO language, such as Java or C++.
> This was the "textbook" we used in my Object-Oriented Design course; however, the great part about this book is that it reads more as a "narrative" than a traditional textbook. I definitely think this is the best book for learning about design patterns. The GoF book should be used as a reference, after you understand them better.
> All I can say is do not judge a book by its cover, and in this case I mean it literally. I think they are trying to be ironically cool by using stock photos on the cover and within the book. It seems odd to be reading through a "serious" book that look like that, but believe me when I say it will be an eye-opening experience.
But for the love of God, please, please, learn JavaScript itself to a good standard before even touching jQuery.
Even though jQuery makes writing web apps a lot easier and saves you a lot of development time, it is still a JavaScript library and as such, if you don't have a good grasp of JavaScript, you're going to be writing jQuery code that may well work correctly, but you're not going to have any idea why it works correctly and as such, debugging and writing advanced jQuery code is going to be a nightmare.
I appreciate that you might not want to spend any money on learning JavaScript, but if you're really interested in the language and want to know it well (and you already have a solid foundation in programming), then I highly recommend getting JavaScript: The Good Parts and reading through that. It's short (176 pages), you can read it in an afternoon (though the first time round, some of the stuff might go over your head), and although it may be very opinionated, most of what Crockford says is pure gold and at the end of it you will have a thorough understanding of how JavaScript works and how you can write good JavaScript, which will aid you tremendously when you start using libraries such as jQuery.
Apologies for my rantiness, it's just that JavaScript is seen as a 'toy' language by many, a simple language that people can just jump in and use without learning it first, as evidenced by people suggesting diving straight into jQuery, which is a reputation that I think is undeserved. JavaScript may not be the prettiest of languages, but it's here to stay, and if you learn to use it properly, you'll find that beneath the design mistakes lies a simple and beautiful programming language that just wants to be loved.
Here are a few of my favorites:
Design patterns:
The JavaScript language:
And as a general language reference, MDN is the best: https://developer.mozilla.org/en-US/
Hope that helps!
This is awesome! I've been slowly getting more and more interested in hardware, and this is something I would absolutely love to do. I just don't know where to start.
I've been reading a couple of books about learning lower level stuff, and planned on working my way up.
I'd really like to get out of webdev and into low-level programming, or even hardware design and implementation. There's sooooo goddamn much to learn, that I doubt I'll be ready without getting a BS in Comp. Engineering, and maybe a master's as well.
(I'm absolutely a beginner, and if anyone is interested in the books I've been reading, these are they:
Also Code: The Hidden Language of Computer Hardware and Software. It literally starts out with telegraphs, and shows how, if you are sufficiently crazy, they can be assembled into a working computer. Then it shows how you can write software for your telegraph-relay-cpu. A great read.
Code Complete
Probably the best book on "thinking like a software engineer" is Code Complete.
For now, here are a few general tips off the top of my head:
> I first build a very simple prototype that has some basic actions and game principles I want to have in my game. I do not care for design nor code quality.
IIRC, this technique is highlighted in Code Complete. The key point the author made there was that it's OK to take shortcuts while prototyping, as long as you're willing to throw all that code away before doing the real work. (Of course, it's not that black and white.)
Code Complete 2nd Edition is what you want.
Ooooh you're a super new :)
Many people hate it but w3schools can get you started:
If you want to buy books check out:
It's super noob friendly and the book looks amazing.
Note for others: The same authors have a book on JS. Again it's mostly introduction material but it's fun to flip the pages :)
(Not affiliated to the authors).
Before becoming a developer, I was running a part-time freelance design studio while working at a coffee shop for a few years. That worked out well for where I was at in my life, but I always wanted to move towards working in an agency to get more experience.
I ended up applying for a few designer positions at small local agencies, and finally got an interview... even if it ended up being a job opening for a front-end developer, not a designer (the job posting wasn't very clear).
Although they would have liked to hire me as a designer, they just didn't have the need. They said they would hire me if I learned HTML, CSS and a little JavsScript to do some front-end templating and design. And so it begun.
I bought a couple books and crammed in some late nights learning how to make a simple website. Learning JavaScript (basically how to use jQuery) was probably the most rewarding part of that. A few months later, I came back to go over what I learned and landed the job as a front end developer and designer. I started out at around $20,000.
Fast forward to where I am now, I am the lead developer for a small agency. I held onto that drive I had in the beginning to delve deeper in computer science via MIT's OpenCourseWare on YouTube. Within just a couple years, I've more than tripled my salary, and pushed myself to areas I'd never thought I'd be able to go (or even be interested in going).
I still do a little bit of design, but I found that my real passion is in development and I plan to continue growing my skillset.
I hope this at least encourages somebody to pursue their career in development. If you can't land a job now, just continue learning until you do land that job. I had to wait nearly 6 months before I finally got that second interview, and it changed my career (and really, my entire life). There's a plethora of courses online at sites like Treehouse and of course YouTube.
Good luck!
Learn C. Eventually Assembly. Buy this book too: http://www.amazon.com/Hacking-The-Art-Exploitation-Edition/dp/1593271441/ref=sr_1_1?ie=UTF8&amp;qid=1334790681&amp;sr=8-1
OSDev - http://wiki.osdev.org/Main_Page
Kernel programming - http://stackoverflow.com/a/12818021
Books:
Hacking the Art of Exploitation - This is a fun book that has a lot to do with programming in C, exploring memory and disassembly.
Practical Reverse Engineering - this is a very informative and short book which is pretty close to the metal in regards to memory and all that but is strongly focused on its namesake so I wouldn't get it if it's not your thing.
LittleOS Book - like 76 pages on building your own OS (also free!).
For anyone interested in this kinda stuff I would really recommend "Code: The hidden language of computer hardware and software"
https://www.amazon.co.uk/Code-Language-Computer-Hardware-Software/dp/0735611319
Could read a book based on your interests in computer science, e.g. AI, Machine Learning, data science etc.
A good book that I recently picked up was
[Code: The Hidden Language of Computer Hardware and Software by Charles Petzold] (https://www.amazon.co.uk/dp/0735611319/ref=cm_sw_r_cp_api_qB4TBbG90ANHN)
acabei de ler o Code (1999). É uma boa introdução ao funcionamento de um computador baseada na sua evolução na história.
Code: The Hidden Language of Computer Hardware and Software from Charles Petzold does just that, starting from the simplest form and going through all the different steps we took to get to where we are today. Well worth a read!
The 86 stands for the instruction set for the cpu. Basically, every chip designed in the world accepts input and output, but in different ways (different numbers of connections, ordering). All of those chips have more or less backwards compatibility with regard to that, so it makes it easier for others to develop around that.
So there is a meaning conveyed, though it probably isn't important to you if you aren't developing hardware or writing assembly.
I strongly recommend Code by Charles Petzold which explains the origins of these chipsets. Basically Intel put out the 8080 in 1974 which was an 8-bit processor, then the 8086 in 1978 was a 16-bit processor, so they just ran with the number scheme (6 for 16 bit). The "80" from 8080 probably came from IBM punchcards which were used for the US census (since the 1920s!), which is actually how IBM started, basically as the child of Herman Hollerith who built automated tabulating machines in the late 19th century. Also this is to blame for the 80-character terminal convention. Blame IBM.
What you seem to be asking is "how do computers work?" At any rate, the interaction of hardware and software is fundamental to any computer system, whether it's your fitness band or your cell phone or a supercomputer or the computer in your car engine or The Next Big Thing.
How that works is a really, really big question. Rather than attempt to answer it, I'll suggest you check out the book Code by Charles Petzold. It explains how computer hardware and software work, starting with basic electrical circuits and building up layer by layer until you're running an operating system and application software. That might seem like a lot to cover, but Code does it simply and cleanly, in a way that just about anybody can digest and understand.
Don't Make Me Think by Steve Krug. Amazon link
If you haven't read The Practice of System and Network Administration yet I would suggest starting there. It is an easy read and very informative. It helped me get into the mindset of a sysadmin.
You need to start reading. I don't even know where you should start..maybe here would be best: http://www.amazon.com/Practice-System-Network-Administration-Edition/dp/0321492668
I started in the same boat as you, but I've been doing this for a few years now. Probably worse than someone who came up in a very structured environment.
Get a orchestration mgmt system setup, like salt, puppet, chef, etc.
Get monitoring set up if you haven't already. Central logging and automatic alerting, etc. If you have time, set up visualization for logs so you can see trends, using things like splunk or elk.
Make sure you have backups, and make sure you can actually restore from backups.
These are good, and written by someone with way more experience than me: 'The Practice of System and Network Administration, Second Edition', 'Time Management for System Administrators'
These are all good points.
With respect to Design Patterns, I feel that the holy grail is Design Patterns - Elements of Reusable Object-Oriented Software by Gamma et al.
One of the things we can do to make our lives harder in software engineering is muddle terminology. It adds needless friction to our job if when you say "flernb" you're referring to a widget but when I use say it, I'm talking about a whozit.
In low level code, we're pretty good about sticking to the first term that was coined for something. If you have a series of objects, each with a reference to the next, you'll probably call it a "linked list", just like I would.
But when it comes to higher-level architecture and design, names get a lot messier. Fortunately, some dudes wrote a book that tries to be the beginning of a taxonomy for architecture. Ultimately, the names they pick are arbitrary, but if we all agree to stick to them, then they become concretely useful.
What the author describes here is not a proxy. A proxy is a local object that represents a distant one, usually on another machine or process. It's not a very common part outside of distributed systems.
The author created an adapter.
Here's a rough outline, from high level to low(ish):
Extra Credit
That will get you started but there's tons more. The best thing you can do is write code and read code and be patient.
I'm a bit confused on your background with CS. You are you are aspiring to become a machine-learning researcher, yet evidently it doesn't seem like you have much of a background in CS which is why you're asking I assume. In any case, I'd recommend reading books on C++ and books on data structures/algorithms separately.
For algorithms/DS I recommend The Algorithm Design Manual and Introduction to Algorithms (commonly referred to as CLRS). Recommended books for C++ are on isocpp.org.
If you want to learn machine learning concepts and algorithms then I recommend some books on artificial intelligence and machine learning. To start with, Artificial Intelligence: A Modern Approach
then ISL. And/or potentially some associated MOOC courses, I recommend Learning from Data it's a really good course which teaches you fundamentals in machine learning such as learning theory and asks questions for why you can learn and etc.
In general, with all these books, you could possibly learn C++ by implementing their exercises or specific algorithms. Some examples would be basic CS related things binary search, sorting algorithms, heaps/priority queues and their associated implementations in the standard library. Then specific to Machine Learning you could implement decision trees and as an extension AdaBoost, a perceptron or a more generic neural network, and the list goes on.
http://www.amazon.com/Introduction-Algorithms-Edition-Thomas-Cormen/dp/0262033844
I won't directly link to a PDF version of it, but it's out there...
I suggest you to not waste too much time reading 15 different books on algorithms or spreading on 15 different resources (YT videos, online courses, forums, tutorials, etc.). Stick to 1 or 2 good books (try Introduction to Algorithms and, if you're completely new to algorithms, and have no idea what are they and what is their role in computer science and science in general, I recommend book by same author that could make a good preparation to previous book; it's called Algorithms Unlocked ) and start applying that knowledge in the run (solving problems). Remember: don't waste time on hundreds of resources; they may be great and offer some really high quality information about topic, but you just don't have time to go through all of them. Good luck!
Introduction to Algorithms, 3rd Edition (MIT Press) https://www.amazon.com/dp/0262033844/ref=cm_sw_r_cp_apa_89sSAbDN1RQ5V
That's probably the best book for data structures and algorithms out there. It's somewhat pricey but I use it all the time even for work things. You can probably find a free PDF with some digging. Look at the chapters in the Data Structures section particularly the elementary structure and hash map. The trees aren't covered in this course I believe.
You will want this book sooner rather than later too.
CLRS - Introduction to Algorithms
I don't think you'll find just one -- computer science is too broad, even in the scope of what you're asking for.
You can probably find a reasonably readable algorithms book that'll introduce things like Big-O, Big-theta, Big-omega, graphs, trees, etc. Some of that bleeds into the "data structures" topic area (and vice-versa). This one is highly-regarded, but I couldn't say whether it's "for you" or not -- it's a bit textbooky.
Don't Make Me Think is an interesting book that if you can find it in your local bookstore and browse through it might be helpful. It's a small book so you could scan through and see if there are interesting bits that might be useful.
On the whole, though, I'd suggest you find an editor to SEVERELY cut down the amount of text that needs to be read for instructions if you find that people aren't reading it.
Page 45 of the book I mention is a chapter called Omit Needless Words (needless is crossed out). A couple of quotes from the chapter:
"E.B. White's seventeenth rule in The Elements of Style:
"17. Omit needless words.
"Vigorous writing is concise. A sentence should contain no unnecessary words, a paragraph no unnecessary sentences, for the same reason that a drawing should contain no unnecessary lines and a machine no unnecessary parts."
On the next page a section starting with the bold line:
"Instructions must die
"The other major source of needless words is instructions. The main thing you need to know about instructions is that no one is going to read them - at least not until after repeated attempts at "muddling through" have failed. And even then, if the instructions are wordy, the odds of users finding the information they need is pretty low.
"Your objective should always be to eliminate instructions entirely by making everything self-explanatory, or as close to it as possible. When instructions are absolutely necessary, cut them back to the bare minimum."
Then there are some examples. The writer is a consultant for web usability and has been doing it for years and the suggestions are based on his (and others') research. You are finding the same thing that others are finding: they aren't going to read the instructions. See if you can find another way. If you want some ideas, poke through the book (or others that are like it) and see if you can configure a method that makes it self-explanatory as suggested by the writer.
Without seeing the site itself, I cannot offer much else.
Good luck!
Took me too long to figure out the search box wasn't a button.
Don't make me think
Edit: Its not even a cursor on mouseover in chrome.
You'd probably have better luck with this at /r/design_critiques
But, for now, there's a ton of spacing issues and bugs that come up when going between different viewports. (you're primary navigation only shows the first two links at mobile size) Also, your social media icons at the bottom appear to be skewed and could use more padding. If I was you I would go back and redesign for mobile-first. Maybe even look into using bootstrap
As far as basic visuals go, You're going a little heavy on all the jquery and animations. It's hard to focus on any one thing cause there's so many different things poping and bouncing around everywhere. In that respect it almost puts me in the mind of a geocities website(no-offense). Just because you can animate something doesn't mean you should.
Also, you have to click on the icons or arrows in order to read them. And whenever you do, there's no active state on the icons(or any navigational items) to tell me which subject the information is relating to. In web design, un-seen information is always un-read information. Not to mention that I have to scroll past the content to click on the icons (or secondary navigation).
This site doesn't have a ton of content, but for some reason it feels like there's no negative space. I'd say this is mostly due to the fact that your using so much grey. Since there's no real contrast between anything, there's no real negative space. Try making your background color white or super light grey like (#efefef) and see how that looks. This will also help you out accessibility wise, because people with astigmatisms sometimes have problems with contrast may not be able to read your main content at the current moment, no matter what it's size is.
You also want to look at how your currently using your colors and imagery. You need to step back and ask yourself what the functional purpose of everything that is taking up real-estate on the screen. Generally, when people only use one color like orange in a monotone grey pallet, they're utilizing it as an ambient signifier for a call to action (think about how colors change from station to station when you're on a subway). You want to use that color to tell people to "click here!" or "look at this and do something now!". Right now it draws my eye to the name and a selling point, but I have no idea what to do afterword. For reference, check out how these sites are using their accent colors: http://www.awwwards.com/websites/minimal/
TL:DR; In short, there's a ton of web and usability standards along with design principles that you're overlooking. I would advise getting a book like Steve Krug's - Don't Make Me Think and studying it. It's short and fast read and it will save you mountains of time, frustration, and wasted effort. Also, be sure to review that AWWARDS.com link above. Make a list of what you think they're doing right and what they're doing wrong.
Sorry, I hope that wasn't too harsh, I'm just trying to help and sometimes honesty can be brutal.
Don't Make Me Think is a great book if you do ux design
http://www.amazon.com/Dont-Make-Think-Revisited-Usability/dp/0321965515/ref=dp_ob_image_bk
You're essentially asking for a computer science class on algorithms. I would recommend:
Tough call. I mean it sounds like you're setup pretty comfortably, so you don't really need any material goods. That's a great place to be.
Perhaps instead of some gift that can be purchased and wrapped in a box, you could do something else.
This might give you some ideas or perhaps they could find something unique, like an autographed copy of "Intro to Algorithms". I'm really just throwing stuff against the wall at this point, but maybe it might spark an idea.
This book is one of the best out there for overall real world sysadmin knowledge/practices
If you have no background in sysadmin you should definitely check this book out:
The Practice of System and Network Administration, Second Edition
http://www.amazon.com/gp/product/0321492668/
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
Pick up The Practice of System and Network Administration. It's OS agnostic, so you'll still need to research into other OS specific areas, but I found it was a great starting place for fundamentals.
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".
ilk olarak kolay gelsin.
Stanford ve MIT'in online course'lari var itunes university'de ordan bakmaya basla istersen.
Internetten egitimini sevdigin okullarin syllabus'unu alip ordaki kitaplardan calismaya baslayabilirsin zaman kaybetmemek icin. Istersen sana sirali kendi transcriptimdeki dersleri PM olarak atabilirim.
Okulundan aldigin .edu emailini cogu programi bedava kullanmak icin kullanabilirsin. (github inanilmaz bi pack veriyor, %100 suistimal etmeni tavsiye ederim)
Kitap oku ve bol bol kod yaz. Boktan olsa, bozuk olsa bile yaz. Kagit kalemle de yazmaya cekinme (is basvurularinda seni beyaz tahtaya cikaracaklar malesef debugger/syntax checker olmicak)
aklima gelen standart kitaplardan en onde su geliyor:
Bilgisayar temel bilgileri icin de Computer Organization
Eger lise bilgilerinden korkuyorsan cok inanilmaz bi matematik yok (sektorune gore degisebilir tabi). Lineer Cebir (image processing/game-development vs.) ve Olasilik (AI, Machine learning, data analysis vs.) bilgilerini tazele. Eger machine learning falan yapmak istiyorsan ilerde olasilik bilginin guclu olmasi gerek.
Cok net bi cizgi izlemene gerek yok. Gerektikce ogrenme politikasi benden yana cikti su ana kadar ama bu tartisilir.
baska bisi olursa cevap vermeye calisirim.
I would recommend not looking for C# specific books. Language specific books tend to get out-dated very fast and won't be as high of quality.
For this reason you want books like https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844 and https://www.amazon.com/Computer-Programming-Volumes-1-4A-Boxed/dp/0321751043
&#x200B;
I'm personally in the market for data structure books, sadly its a slippery slope when you already have a few.
I'm assuming you are looking for generic algo and data struct taught in college:
Look up a university syllabus online, see the name of data structures, learn and implement them in whatever programming language. Same for algorithm, follow some syllebus, learn an algorithm, implement it. For more theory/math pick up a book, follow one of many mooc or find some university course's slides to work with.
I just did a quick search to make sure it is possible to find syllabuses, here's one of them I found for DS: http://bits.usc.edu/cs104/syllabus.html
Here's one for algo: http://www.people.iup.edu/sanwar/COSC%20310%20Syllabus.pdf
For book, my uni used this for DS: https://www.amazon.com/Data-Structures-Other-Objects-Using/dp/0132129485 (good)
For algo: https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844 (overrated, old and confusing, find something better if you can)
>The next generation of algorithms or smart application of the old ones could create even more upheaval
What, specifically, should we regulate, and how? An algorithm is just a set of steps that produces a correct answer to a problem. Which algorithms do you propose we regulate, and what should the regulations be? Should I go to jail if I implement a C++ solution of the map-coloring problem in a college classroom? Are there whole chapters of the classic CLRS textbook that should be banned from the curriculum?
A vague reference to "the next generation of algorithms" is hand-wavy, and suggests a fundamental misunderstanding of what algorithms are and how they apply to AI.
There is no algorithm that is going to just switch on one day and take over the world. That makes as much sense as worrying that the Pythagorean Theorem will wake up tomorrow and become SkyNet.
Someone else can probably point you to an actual resource, but here are my two cents.
Data Structures and Algorithms is a topic that you don't pick a specific language to learn in. All of the topics covered in algorithms are applicable to all languages, so it's usually a good idea to have a pretty good knowledge of the inner workings of your language of choice. Given this information, the textbook that my class used and it sounds like many other classes also use is Introduction to algorithms
More than likely, your textbook will be Intro to Algorithms. Find yourself a copy and start reading. Even if the class uses something else, it's a great reference to have around.
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
Whatever I need to stay relevant or updated. At this time I'm taking VMware cert courses from Stanly college, just to stay ahead on my own time. If you're just starting out, take Network+ to understand that realm, but there are a lot of routes you can go in. I always carry around these books though:
The Practice of Network and System Administration
Time Management for System Administrators
I also recommend this book:
"The Practice of System and Network Administration"
by Thomas A. Limoncelli
http://www.amazon.com/Practice-System-Network-Administration-Edition/dp/0321492668
You're probably better than you think. Also, you're actually in a better spot than people who get comfortable with their little environment and think they're really great. There's no way you can improve someone who thinks he is amazing at what he does.
Rather than give up on IT, try to find a place where you can work that pushes you harder and forces you to learn new things.
Go read this book:
http://www.amazon.com/Practice-System-Network-Administration-Second/dp/0321492668
What makes someone a good sysadmin isn't knowing everything about everything (you can't) but instead developing really good methods and processes for getting work done.
This: http://www.amazon.com/Practice-System-Network-Administration-Second/dp/0321492668
I wish I'd read it at the start of my career.
Other than than, learn the fundamentals well and you'll be fine.
https://www.amazon.com/dp/0201633612/?tag=stackoverflow17-20
https://www.amazon.com/Head-First-Design-Patterns-Brain-Friendly/dp/0596007124
https://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670
And you could check stack overflow for question on general programming books. I would always go for a general concept
functional programmingoverhow to functional programming in haskell.But I'll be perfectly honest, I'm a victim of the curse of knowledge so I honestly don't know how one should start. What I do remember is that I had huge problems with syntax (how do I tell language X to do a
for (Employee e in employeeList), how do you write a switch and stuff, why would I ever need a ternary operator, and like that.But once you master the basics of how to write x, y and z in your preferred language, you absolutely need to understand design patterns, you absolutely need to understand how code is supposed to be written, you absolutely need to understand data structures, you absolutely need to understand inheritance and polymorphism, you absolutely need to understand lambdas and functional programming.
Then you can get to the more "neat" stuff like the benefits of having immutables, and "job specific stuff" like how to solve race conditions in threading; sockets and web communication, etc.
They seem a like reasonable starting point I think. Repetition is the mother of mastery, the more books the better (in addition to applying what is learned).
Since Mosh is calling out learning fundamentals as important to becoming a good C# developers, I would personally also recommend some general (non C# specific books) too for who are starting out in software development:
There's a ton more, but those are a few that stood out to me. Essentially the more the merrier in my opinion - books, courses, videos, tutorials, and so on. The books I'm recommending here focus on adopting the developer mindset and being successful at it. That's part of the puzzle.
The other part is understanding the technical details including the programming language and frameworks you intend to use.
And finally, for learning about C#, I do highly recommend Mosh's videos/courses (some are free on YouTube, others available on Udemy). He's got a unique ability to explain things clearly and simply in a way that beginners can pick up quickly.
What I'd do is check out his free content first, and if you agree his style is ideal for learning, an investment in one of his courses is well worth it since he'll cover a lot more breadth and depth on each of the topics and they're organized into a super consumable package rather than scouring the internet for various topics.
Learn by experience and by reading is probably the way to go. The gang of four's design patterns is still the de-facto standard:
http://www.amazon.ca/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
I really love this book for Java design patterns though, fun to read and really informative:
http://www.amazon.ca/Head-First-Design-Patterns-Freeman/dp/0596007124/ref=sr_1_1?s=books&amp;ie=UTF8&amp;qid=1333263240&amp;sr=1-1
Then it's a matter of knowing when and where to apply them, which is a harder problem and just an experience thing I'd say.
From wikipedia, and I highly recommend this book as reference material.
The Mythical Man Month published 1975(!)
"Arguably the only classic book in our field"
----------------
Lot of good books listed here, but my advice is to read this book, and play around with some new tool (like git). Now that I think about it, learning git along with reading this book is actually perfect, because you'll learn how to use the tools that we have today that the author dreams of, and why they are so powerful and important.
Yes, this is the perfect break material: git and The Mythical Man Month. Short book too.
LWRellim is exactly right.
Tomorrow morning, go to your local library or bookstore and find this book. You don't have to read the whole thing right away, but if you can spend the afternoon with it at least, it's worthwhile.
Chapter 11 especially is appropriate here, where you're in the position of "flushing it all down the proverbial crapper." Plan to Throw One Away One can also use a line from The Matrix - everyone falls the first time.
I'm not going to say that every software project bombs the first time around. That's definitely not the case. But many times, especially on your first custom programming experience, no matter how well you think you understand what needs to be built, you will paint yourself into corners and discover all kinds of stuff that you had never considered before you started to build the first version.
Depending on where you are in the project, and how things have been put together, you may have to literally toss everything. In your case, you might be able to salvage some UI bits, but your new developer will probably redo everything else.
I have a EE undergrad degree and work as a software developer (mostly web development).
Best advice is to code as much as possible. I second @jewdai's recommendation to study data structures and algorithms -> learning these will give you a solid toolset for solving problems (w/ code) in the future. The bible for data structures and algorithms is:
https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844/ref=zg_bs_132570011_2?_encoding=UTF8&amp;psc=1&amp;refRID=G4V554CGYNTY1J7NT6AZ
You should investigate what type of industry you're interested in. If you're interested in signal processing, check out companies that specialize in that area (I guarantee they need software developers).
Best chance for getting an entry level position would be one where you can leverage your EE expertise, but spend most of your time programming (it's the only way to get better). Working on an embedded system (e.g. firmware) might be a good fit because you need solid EE knowledge as well as software skills.
I would also leverage my alumni network; talk to your classmates fellow grads who are in software now. Get their advice and network; those connections can lead to jobs (or at least interviews at their companies).
Best of luck!
https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844
Best book out there
Books aren't required for first-year CS (they aren't needed for other years either).
Here is the online version of the book they use in COMP 1010. They will give you a link for the COMP 1020 book when you take the course but I'm not gonna look around for it.
General advice for any CS students: A good algorithms book is very handy. I recommend investing in this one. It's gonna be useful throughout your undergrad degree and probably afterward too.
His algorithms class probably used this textbook, but if they didn't, it's pretty much a standard:
http://www.amazon.com/Introduction-Algorithms-Thomas-H-Cormen/dp/0262033844
Don't be deceived by the title, it's more than just an introduction. As the description on Amazon states:
>Some books on algorithms are rigorous but incomplete; others cover masses of material but lack rigor. Introduction to Algorithms uniquely combines rigor and comprehensiveness.
Preface: I'm not being condescending, I know a lot of incredible programmers who never attended a computer science class.
To be honest, this is the sort of stuff you learn about in a computer science degree program (though this would probably fit better in a graduate degree than an undergrad). If it really interests you, you should look into it.
If that's not a really viable option, I can't recommend this book on algorithms highly enough. It talks about runtime, scaling, data structures and graphs, etc. Truly fascinating stuff.
This is a great book for computer fundamentals that you should just read if you have any interest in computer science. But realistically you will not use much from this book in the real world. It is something to read to understand how things work.
You will get a lot more useful things out of a book like Intro to algorithms than SICP. The biggest thing i find self taught devs lack is an understanding of data structures. They know how to code and write solutions but dont know which data structure is efficient or why. They may learn by trial an error that one data structure is better for certain task but dont know why. If you are able to understand how the standard collections library for most major languages work you will be ahead of most devs
You should read CLRS from cover to cover.
I'd start learning more about design and design theory.
Start with The Principles of Beautiful Web Design to get an introduction to Web Design, go on to Elements of Style to learn more about typography and finish with Don't make me think and Above The Fold to get started with User Experience.
Yes, and if you want to follow this deeper into the context of consciousness, check out this book: GEB
There's a series of chapters discussing the localization of brain functions. The author discusses a study on rat brains, in which maze-running rats had significant portions of their brains removed, and were allowed to heal. Most rats were still able to re-learn the maze.
You might like this [book] (https://www.amazon.com/G%C3%B6del-Escher-Bach-Eternal-Golden/dp/0465026567)...Gödel, Escher, Bach: An Eternal Golden Braid, the cover has an even better whatever you call that effect/illusion.
In Search Of Schrodinger's Cat by John Gribbin is a very readable physics and quantum physics history sketch. Might be slightly dated now, although I can't think of anything directly contradicted by recent work. Then again, I'm not actually a physicist :)
The Quark and the Jaguar is quite a bit more complicated, but still quite accessible to the layperson and has a lot of interesting stuff.
Slightly less sciency, more maths/logic/computation is Gödel, Escher, Bach: An Eternal Golden Braid
A Guinea Pig's History of Biology is pretty much what the title says, although there's an awful lot about fruit-flies too. Quite a good review of the history of biological experimentation, especially genetics.
H2O: A Biography of Water from a previous editor of Nature, covers water across a variety of fields. The second half of the book is mostly a rant about cold fusion and homoeopathy though, from what I recall, but the first half makes up for it.
Most general-audience things by Richard Feynman are well worth the read. He's got some great physics lectures, and his autobiography (Surely You're Joking, Mr Feynman?) is fun, but more for the anecdotes than the science.
Those are off the top of my head. If its something in a particular field, I might have some other ideas I'm currently forgetting.
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.
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)
In all fairness to him, it was when you showed enough merit in your work.
And one can make a great deal of progress in 4 years of real world software development. But by the language of highly recommended The Pragmatic Programmer: From Journeyman to Master, you were almost certainly still a journeyman back then. I would guess it took me > 10 man years to obtain mastery.
Two things: The coursework from my CS degree, and reading books about software engineering.
I've spoken in other places about the former, and for the latter, I recommend The Pragmatic Programmer, Code Complete, and Design Patterns: Elements of Reusable Object-Oriented Software
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.
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.
Check the syllabus and get a head start on the topics covered. My two favorite C books are C Programming: A Modern Approach and C Programming Language. The first one is for absolute beginners, while the second one is for someone who already knows the basics of programming.
I suggest disconnecting the two. You need to have a firm grasp on C or C++ programming before going into graphics. It's a long road, but worth it.
This book is considered the authoritative source on C programming, written by the creator: http://www.amazon.com/C-Programming-Language-2nd-Edition/dp/0131103628
Here are some text based tutorials that I used to learn OpenGL recently.
http://openglbook.com/the-book/
http://www.swiftless.com/tutorials/opengl4/1-opengl-window.html
http://en.wikibooks.org/wiki/OpenGL_Programming
Good luck!
If you're looking to learn C, get K&R.
Kernighan and Ritchie
+1 for mentioning malwareunicorns Reverse Engineering Malware 101 course. I'm pretty excited about starting that after I'm done with some Powershell stuff.
Books for: /u/Kreator333 and /u/curiousdoggo
C/C++:
Assembly/C:
Also OP while your learning the basics here do as many examples as you can. Don't just read it and assume you know everything. For C you can try coding a bunch of classical ciphers and for ASM, debug the assembly of simple programs in gdb. (check out godbolt) or try coding a echo client/server in Nasm.
I haven't read either of those, but I did enjoy and find a lot of value in K&R and 21st Century C.
Any book on technology. Like this one. Oh yes, most Indians wanting out are settled in the US or the UK or Australia nowadays. I'm mostly a lurker here and on reddit. I don't understand most of the posts, especially the ones on politics, although I'm learning new terms like Dail and Taoiseach and I'm pretty sure I don't know how to pronounce these words. I'm trying to participate in self posts like these.
I've been self-teaching myself C through various books/courses/series the last few months (I'm still not that great), and so I have some suggestions about good places to start learning.
Books:
Courses/Videos:
Resources:
Other than that, you should maybe look into trying out Linux, because it's more developer-friendly than Windows (such as having a C compiler out of the box). And the whole kernel and many core components of the OS are written in C, which are all usually open source, so you can learn from, and contribute to them.
Good luck, friend.
The C Programming Language by K&R is probably the first book people recommend.
Learn C The Hard Way is more hands-on, but if you already know other programming languages youll be fine.
I dont know about any interactive courses, but HackerRank has lots of challanges you can solve in a multitude of languages (including C) which is pretty close to CodeAcademy. Keep in mind that it gets hard pretty quick, so it is better to be somewhat comfortable with your chosen language before doing them.
If you want to know what programming is like, try Stanford's CS101 course. It's very basic but gives you a taste of what you can learn. You can breeze through it in a week or two. Don't worry about memorizing the code, just focus on the concepts.
If you finish that and enjoyed it, you can try M.I.T's 6.00 1 course. It teaches you Python, one of the easier programming languages to start with. This course is longer than the first one and is an actual programming course. It recommends the book Introduction to Computation and Programming Using Python if you need it.
After that, I would say give Harvard's CS50 online course a go. This course teaches you the C language and is easier to complete if you did the first two courses. This course recommends the books: The C programming language book or C programming: an absolute beginners guide for a more beginner friendly (and budget friendly) option.
Good luck and have fun
Pick up a copy of K&R (ANSI edition). It is thin and the definitive reference. You can burn through the exercises pretty quickly, especially if you have used Java, C++, or C#.
Ridiculously-priced hard copy (IIRC, I paid about $20 for my copy.)
E-book PDF
The C Programming Language is what I'm reading now.
http://www.amazon.com/exec/obidos/ASIN/0131103628/ref=nosim/schmcreadesis-20
I would make the logo a blue C, like in the title page of The C Programming Language: https://i.imgur.com/yMpmgEp.png
I believe this is a pretty good book for legacy / maintenance systems:
https://www.amazon.com/Working-Effectively-Legacy-Michael-Feathers/dp/0131177052
I'd recommend this one: https://www.amazon.com/Code-Language-Computer-Hardware-Software/dp/0735611319
It's very enjoyable to read and definitely increases one's understanding of how computer conceptually function. Petzold also makes it very easy to understand what he is saying in his explanations.
When I was a young teenager I read (most of) a book called Code.
This was absolutely fantastic. It didn't just talk about programming or about software, it explained the concept of a code and the work that we do from the ground up. It literally started from light bulbs and switches and went to microprocessors and programming languages. This is the book that helped me bridge the software-hardware cognitive gap. Eventually it got to be too much for me, but in my defense I was 12-13 at the time. Even so, the parts that I did get through stuck with me.
I'm going to go back and reread it.
The book isn't going to cover design patterns or microservices, but IMO it's best thing to give computer scientists context on what we're doing here from an engineering perspective (with sipser as the book from the mathematical perspective)
>I want to be able to understand how computers work
Code: The Hidden Language of Computer Hardware and Software
I was on the search for the same as you a couple of weeks ago and people recommended the book above. I just recently started reading it but hopefully someone who has read it can chime in with their opinion.
Okay, I'm gonna plug this in here. I hope this doesn't get buried because when I saw someone asking about low level stuff here, I couldn't help but make this recommendation.
For anyone that wants to learn more about low level computer stuff such as assembly code should read the book Code: The Hidden Language of Computer Hardware and Software by Charles Petzold. I've been reading it recently and I'm really glad I picked it up. It really delves into how a computer really works, like how languages relate to the circuits on a board.
So yeah, /u/DEVi4TION, I recommend picking this up if you wanna know about more stuff like this. Then maybe try your hand at actual 6502 programming later :P
Code Complete by Steve McConnell
It's not quite what you asked for, but the parent of this reply answers that.
JavaScript: The Good Parts offers a wonderful Computer Science style discussion of JavaScript.
You would love Godel Escher Bach by Douglas R Hofstadter. It won the pullitzer prize and is basically just a really good popular math/computer science/art book. But a really excellent jumping off point. Yes it lacks mathematical rigor (of course) but if you are a bright clever person who likes these things, its a must read just for exposure to the inter-connectivity of all of these topics in a very artistic and philosophical way. But be prepared for computer code, musical staff notation, DNA sequences, paintings, and poetry (all themed around Godel, Escher and Bach).
I don't follow?
At some point we started asking questions about the world. There came a time where 'something' emerged in us and we started questioning the world around us.
Questions are investigations about how the world (and here 'world' is everything in the immediate environment) works. This leads to 'what if' scenarios, equivalencies 'is this thing like the other?' and sets 'I belong to the group called 'men', she belongs to the group called 'women'. In the group called 'women' there is the subset of 'women' that are my offspring. Godel, Escher, Bach yourself on sets and other concepts.
So, we learned how to ask questions and the answers to those questions lead to more questions. All this leads to the internet and us meeting. Our interaction is the result of an unbroken chain of questions that has brought us from the savanna all the way to here. Think about that.
What a great question, and an interesting example. For those confused by OP's example, check out Gödel's Incompleteness Theorem on Wiki. Better yet, read the insightful and very trippy Pulitzer Prize winning book, Gödel, Escher, Bach. Gödel's theorem is a bit abstract but it was both a monumental and surprising discovery. It's not just mathematical -- it's meta-mathematical, in that it reveals the limitations inherent to any mathematical framework or system. From wiki:
>The first incompleteness theorem states that no consistent system of axioms...is capable of proving all truths about the relations of the natural numbers (arithmetic). For any such system, there will always be statements about the natural numbers that are true, but that are unprovable within the system. The second incompleteness theorem, an extension of the first, shows that such a system cannot demonstrate its own consistency.
I'll point out an obvious one, though it's more to do with the aesthetics of the psychedelic experience rather than insights or ideas. Psychedelic hallucinations tend to be geometric, with lattices, grids, spirals, and perhaps most intriguing of all, fractals. All these are geometric forms that can be rigorously defined and analyzed by math. Fractals are especially fascinating because they exhibit self-similarity at every scale, appear sometimes in nature (for example, coastlines), and look extremely trippy. (Seriously, just look at these zoom-ins of the Mandelbrot set, discovered in 1978.)
Gödel, Escher, Bach: An Eternal Golden Braid by Douglas F. Hofstadter. The section on Ant Fugue blew my mind away.
Google "c# github projects for beginners". Theres a whole bunch of interesting stuff out there. You could also download/fork a github repo and try to extend a project, or build on top of it.
I think this repo has been posted here before, but learning design patterns is really useful prior to designing something from ground up. https://github.com/Finickyflame/DesignPatterns
Here's a good beginner's book on design patterns. https://www.amazon.com/dp/0596007124/ref=cm_sw_r_cp_apa_i_FmHsDbGWQ0NTJ
The official tutorials are not bad:
http://download.oracle.com/javase/tutorial/
I also recommend Head First Java as a book:
http://www.amazon.com/Head-First-Java-Kathy-Sierra/dp/0596009208
You have semicolons after your if statements. Though I don't see why it's not printing both statements. In fact, I just ran what you have posted and it did print both. Did you mistype something by chance instead of copy/paste?
Your if statements should be something like
if (mrk >= 440) {
// print message
} else {
// print other message
}
Note that there are no braces around the if statements like you have either.
Edit: You should probably get a better resource for Java than a For Dummies book. Head First Java is often recommended. You might try the official Java tutorials as well.
For Android I can recommend the Udacity course. Basically they teach you the building blocks of any Android App by making you build a weather App. It's very... "holdy-handsy" though. Each concept is broken down into manageable chunks (small coding exercises). You get to watch videos explaining the concept then you gotta complete the example programs they provide (It's basically just following some TODOs that are commented in the code), and at the end of the class you have to put it all together and add that to the main weather app.
They won't explain any Java syntax / concepts that they use but if you know some OOP language it won't be too hard to understand what they are doing (though it's gonna be a bit harder to understand why they are doing it the way they do).
Top tip: every exercise is accompanied by a short video where someone will show you how to code everything. My suggestion is to watch the video once to get the basic gist of it then go and code by your own (using the Android Reference if needed). Avoid just copy-pasting what you see in the video. It might seem sluggish and hard but that's how you'll get the most out of it.
As for Java, I don't know any course that teaches it in that manner but I can recommend Oracle's Java Tutorials and Head First Java. Oracle's tutorials are really comprehensive but imo they can get a bit dull, while the book is really fun and easy to follow (and if you know a concept already you can just skim that chapter and move on).
I'm a big fan of JavaScript: The Good Parts. I'm not sure if it is quite intermediate, but it is a terrific (and short) read.
Secrets of the JavaScript Ninja is a bit more advanced. It's written by the guy who created jQuery. I found some of the coding style to be sort of strange, but it does have a lot of great information.
I can really recommend this book: http://www.amazon.com/JavaScript-Good-Parts-Douglas-Crockford/dp/0596517742 (not an affiliate link ;) )
JavaScript is amazing if you embrace it's prototype-orientation and assorted ugly warts.
Speaking as someone who was great at reading but bad at retaining, learned to retain while in college getting a liberal arts degree, and has been reasonably successful at teaching himself programming languages since graduating...
Read things twice. Not necessarily the whole book, but for each paragraph you come across, think about what it's saying. If it is introducing something new, then read it a second time.
Read things out loud. Not even stuff you're trying to learn, and not necessarily to an audience. But (if you're taking my advice about reading things twice) do your second go-through out loud. You'll find that often your intonation is wrong - you didn't catch that something was a question, or you thought you were on the last clause of a sentence but you were wrong. Dedicate some small part of your brain to listening as you read out loud, and fixing these problems. This will help you get the structure of a thing - which parts are introductory, cursory, or parenthetical, and thus can be skipped over; which parts are REALLY IMPORTANT, which parts are actually pretty damn funny but you missed the joke the first time...
Don't just read. Explain to people what you're reading. My housemates and girlfriend have probably sponged half the stuff I've taught myself (about programming, musical instruments, bicycles, pretty much anything I've decided to learn about) because I'm constantly asking if they mind if I explain a concept to them. It helps that we're all young, intelligent, curious people.
Have a conversation with the book. When you come across something that seems wrong, don't just plow through - see if you can figure out why it just said what it did. Maybe you read it wrong. Maybe you misunderstood an earlier concept. Maybe you thought the dude was speaking when it was the lady. The point is that after that initial moment of confusion, you'll have a moment when it Suddenly Makes Sense - cultivate your enjoyment of that moment. It's one of the greatest pleasures of reading.
Do the stuff you're reading about. In the case of programming, do the exercises. If you're reading a book about a foreign language, acclimate yourself to the rules of pronunciation. In a work of fiction, hand the part of you that experiences emotions over to the author and let him or her shove you around to whatever he or she wants. If there's a math concept that doesn't quite make sense, pull it up on Wikipedia and read the links that describe any of the fundamental elements that you're missing.
If you want to get into programming, read one of the Head First books. They talk a lot about effective ways to learn things, in addition to putting those principles into practice in how they teach programming. This book started me on my current routine of reading a chapter of (whatever computer book, currently Code Complete) when I first wake up in the morning.
Apologies for the wall of text, I hope that was helpful. I'll edit to add anything that I think of.
[Code Complete] ( http://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670) 960 pages, no fluff, essential reading to any programmer.
These are the coding conventions every Java developer should follow:
Oracle's Code Conventions for the Java Programming Language
If there are industry-wide coding conventions for the particular language, follow those. (i.e.: Java , C#); otherwise, most companies will enforce some conventions (i.e. most companies have their own C++, C coding conventions); otherwise, establish some, and stick to it. This book has general guidelines on coding conventions and best practices: Code Complete 2
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
There are a lot of different strategies.
Basically you asking a methodology question and not a programming question. If you are asking questions like this you should probably start reading books like Code Complete: A Practical Handbook of Software Construction, Second Edition
Perfectly normal. After 15 years of amateur programming I still make stupid mistakes and have dumb days and weeks when I get or seem to get nothing done. But like the saying goes it's only a problem if you don't learn from your mistakes. I can write a class get it working and come back to it in a week and can't for the life of me figure out why I'd done something a certain way. So my approach now is to break the program into modules and then classes which are independent as possible. Test those classes and finalise them as much as possible so I never need to modify them again and make notes on how they work. In fact I seem to make notes on everything I do. From theory to how classes in an API works to my own code. I've read somewhere programming is one of the most mentally intensive activities a human can do, so don't be surprised if you find it difficult at times, every programmer does I'm sure. Good luck 👍 oh yeah I forgot I'd strongly recommend reading code complete it helped me out more than any other programming book and it's lessons apply to any language. Think it even has a chapter on human factors
I agree with /u/Supernovadm I like tutorials where you can type the code rather than just read it. I think treehouse is great, especially when it comes to just starting.
If you pay for a month or two there you can rage through most of the html/css content they have and have a pretty good grasp.
If you're looking for a good book to start on these topics though I would suggest Html & Css: Design and Build Websites by Jon Duckett.
http://www.amazon.com/HTML-CSS-Design-Build-Websites/dp/1118008189
It's a super simple book. Very Visual and easy to read. Great start. Hope this helps!
I may add the book.
Hacking: The Art of Exploitation
https://www.amazon.es/Hacking-2e-Exploitation-Jon-Erickson/dp/1593271441
Now I'm imagining a book titled "PHP: The Good Parts". (Kind of like "Javascript: The Good Parts".) Only, it's less of a book and more of a pamphlet.
Advanced
Medium
Old, but probably still relevant
Yet to be released, but you can get the in progress pdf from the publisher
Docs
The one that everybody recommends
HTML5 spec
HTML5Rocks
Latest Webkit News
Other than that build build build. Make demos and play. Ask questions here or on stackoverflow and read other people's code. Also, lots of great old JSConf videos out there.
Check out JavaScript, the Good Parts. Imo the best beginner JS book. No one should be able to save a .js file without reading it :)
You can learn angular without learning JS first, but it sure will help you go a lot further if you understand the fundamentals of JS.
http://www.amazon.com/JavaScript-Good-Parts-Douglas-Crockford/dp/0596517742
Having never read a Deitel book myself, I'm honestly curious why 65x finds them so compelling.
I would point out that based on some of 65x's previous posts, he or she is not an expert. This isn't a criticism at all, but people should take 65x's endorsement as coming from a beginning programmer and not a teacher or professional.
(Full disclosure: I'm a professional software developer with over 20 years in the industry.)
EDIT: As far as recommendations, if you can give me a general area of interest and it's in my wheelhouse, I'd be happy to oblige. I often recommend this book, although it's not really germane to this discussion.
There are plenty of tutorials on the net - http://computer.howstuffworks.com/pc.htm I would also recommend this book - https://www.amazon.com/Code-Language-Computer-Hardware-Software/dp/0735611319
A famous artefact of early computing is the boot-strapping process where the goal is a self-hosting compiler - which lets you write the compiler for a new language in the new langauge. However to get to that point a lot of earlier innovations were needed.
Take all of this with a pinch of salt - the order and the details may be wildly inaccurate, but the overall ideas viewed from afar give an idea of how we got to the point that we can choose our own language to write a compiler for another language..
To start with, raw binary values had to be set in order to define and run a program. Those raw binary values represent instructions that tell the hardwaer what to do and data that the program needed to operate. This is now usually referred to as machine code.
At first you would enter values into computer storage using switches.
Since that's so tedious and error prone, puched cards were developed along with the necessary hardware to read them so you could represent lots of values that could be read toagether. They had their own problems but it was a step forward from switches.
After some time symbolic instructions were defined as a shortcut for several machine code instructions - now usually called assembly language. For example put the value 8 and store it into a memory location 58 could be written as ST 8, [58]. This might take 3 machine code instructions, one represents the store instruction, one the value 8 and one the location 58. Since now assembly language could be written down it was easier to understand what the computer is being instructed to do. Naturally someone had the bright idea to make that automatic so that for example you could write down the instructions by hand, then create punched cards representing those instructions, convert them to machines code and then run the program. The conversion from the symbolic instructions to machines code was handled by a program called an assembler - people still write programs in assembly code and use assemblers today.
The next logical step is to make the symbolic instructions more useful and less aimed at the mundane, physical processes that tells the computer exactly how to operate and more friendly for people to represent ideas. This is really the birth of programming languages. Since programming languages allowed you to do more abstract things symbolically - like saving the current instructions location, branching off to another part of the same program to return later, the conversion to machine code became more complex.Those programs are called compilers.
Compilers allow you to write more useful programs - for example the first program that allowed you to connected a keyboard that lets you enter numbers and characters, one connected to a device to print numbers and characters, then later to display them on another device like a screen. From there you are quite free to write other programs. More languages and their compilers developed that were more suitable to represent more abstract ideas like variables, procedure and functions.
During the whole process both hardware - the physical elctronic machines and devices and software, the instructions to get the machines to do useful work - were both developed and that process still continues.
There's a wonderful book called Code by Charles Petzold that details all of these developments, but actually researched and accurate.
Try this book: Code, which is a bottom-up approach. Depending on how rigorous your college CS curriculum was, it'll be either a good review of your college classes or mind-blowing, but I think that the approach that the book takes is really great.
I'd also recommend Code: The Hidden Language of Computer Hardware and Software by Charles Petzold. I recently finished reading this book after having it recommended by a post on Reddit a year or two ago. It starts off with a lot of basic information, covering Morse code and braille, and moves along in the development of code and hardware up until you actually create a functioning computer in the book. The later chapters were harder to get interested in, but the first 3/4 was very excellent and actually covered more than my computer architecture class in undergrad.
Yup!
http://www.amazon.com/Code-Language-Computer-Hardware-Software/dp/0735611319/ref=sr_1_1?ie=UTF8&amp;qid=1409776169&amp;sr=8-1&amp;keywords=code
Code is a great book that helped me understand programming on an abstract level
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.
This is the best video on the subject I've ever seen. http://youtu.be/VBDoT8o4q00
Of you want to learn more I very very very strongly recommend this book. http://www.amazon.com/Code-Language-Computer-Hardware-Software/dp/0735611319
Code: The Hidden Language of Computer Hardware and Software
This book starts with flashlights and Morse code and Braille, goes to telegraphs and electricity, works it way up to Boolean logic gate circuits (still using the components from telegraphs!) and then goes all the way to programming languages and computer graphics.
Falls du wissen willst wie eine CPU funktioniert und was Assembler ist und vor allem wo das alles her kommt und warum es funktioniert, dann kann ichdir Charles Petzold - Code: The Hidden Language empfehlen. Er fängt mit einfachen Morsesignalen an, leitet dann Logikgatter her und am Ende des Buches hast eine eine funktionerende CPU.
"Code" by Charles Petzold is a great book that does that. Starts with a simple flashlight switch, and builds on that example until you have a working processor.
Code: The Hidden Language of Computer Hardware and Software https://www.amazon.com/dp/0735611319/ref=cm_sw_r_cp_awd_FeDzwbRQ2ZDDP
Check out The Annotated Turing by Charles Petzold. It's Turing's paper on the Entscheidungsproblem which introduces Turing Machines, annotated with a lot of background information and some stuff about Turing's career. Very interesting stuff.
I can also recommend Code, by the same author which describes how a computer works from basic principles. It's doesn't have a lot of material on Turing, but it's certainly an interesting read for anyone interested in Comp Sci.
Read Code by Petzold
You'll have a far greater understanding of how things work at a basic level than everyone else.
For a gentle introduction, CODE: The Hidden Language of Computer Hardware and Software is a really pleasant read. It works its way up gradually, so maybe not the best fit for a physics student or someone who already understands the fundamentals. For someone new to the subject it's a great fit, however. Otherwise I see Patterson and Hennessy recommended.
Code Complete
Big Java Late Objects
The Pragmatic Programmer: From Journeyman to Master
The Mythical Man-Month
Android Programming: The Big Nerd Ranch Guide
cracking the coding Interview
Introduction to Algorithms
Thinking in C++
Hmmm...
Like everyone said, it depends. Deep nesting can often be a code smell. This book will help answer your questions:
http://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670
But more importantly, please don't call yourself (or others!) a bad programmer! I'm sure you're just joking, but there's this weird vibe in the scene where people's worth is evaluated on their code. It kinda sucks. You're not your code.
A better question would be: does this pattern indicate poorly written code? The answer is GOTO: Hmmm...
While you said books haven't helped, give this one a try: http://www.amazon.com/Head-First-Design-Patterns-Freeman/dp/0596007124
This website is pretty good also: http://sourcemaking.com/design_patterns
The book, Head First Design Patterns, is actually pretty good.
You could also read the book that started it all, Design Patterns: Elements of Reusable Object-Oriented Software. Although good, it is a dull read - I had to force myself to get through it.
Martin Fowler is also really good, in particular, I thoroughly enjoyed his book Patterns of Enterprise Architecture.
If you want more of an MS/.NET slant of things, you should also check out Dino Esposito. I really enjoyed his book Microsoft .NET: Architecting Applications for the Enterprise.
My recommendation would be to start with the Head First book first, as this will give you a good overview of the major design patterns.
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
I can't believe that no one mentioned Code Complete: http://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670/ref=sr_1_1?ie=UTF8&amp;s=books&amp;qid=1267359531&amp;sr=8-1
It totally changed my perspective on writing applications, no matter what the language or scenario. HIGHLY recommended - every programmer should read it.
This list isn't about "coding" per-se but is more focused on concepts, sw.en., practices, etc.
Thinking in Java is one of my favorites, the definitive introduction to object oriented programming and design.
Code Complete, Don't know anyone who hasn't heard of this so far
The Pragmatic Programmer: From Journeyman to Master
Code Complete: A Practical Handbook of Software Construction is often recommended
The stuff you are learning in CS class is definitely important, but it's orthogonal to the things you will need to learn in the industry.
Read "Code Complete" to get a head start on this stuff. - https://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670
As far as some fun interviews with famous programmers, another great book is https://www.amazon.com/Practice-Programming-Addison-Wesley-Professional-Computing/dp/020161586X
There are several good books on designing good software:
Code Complete
Design Patterns
Refactoring
TL;DR Improve yourself, invest in your future, don't worry about the mistakes...read the books listed at bottom, and practice!
Few months ago I royally fucked up an interview at Microsoft. A really simple question. But I had no experience doing coding on paper instead of a computer.
I spent a lot of time studying various books and paper coding to make sure it wouldn't happen again.
I then had an interview for another (in my mind at the time) dream job. I did fine for all the phone interviews and they flew me over to the west coast for an in person interview for the day. I did well for the first bit until they started pulling out dynamic programming and integer programming questions on me and expecting me. Once again something I didn't prepare for, and f'd up. Didn't get this job either. For the longest time I was really hard on myself at fucking up on both these interviews one after another. Especially this second one since a lot more was riding on it than just the job (another story).
But then I decided I didn't want to have this sort of experience again and expected better of myself. I made myself further improve and brush up on all those concepts as well. Did a few mock interviews with friends, spent some time working on interview type questions on both the computer and on paper. A month or two later I started interviewing again. By this point I was an interviewing machine - and I'm now able to do just about anything thrown at me. I've had my choice of employers and until just recently, was in the situation where I had so many offers I didn't know which one I wanted most. I'll be heading to silicon valley soon at one of the top tech companies in the world with a fantastic offer considering I just graduated.
The point is - learn from the mistakes and improve yourself. I realize you don't want to be that guy spending heaps of time coding outside of work or whatever... but this is an investment in yourself and your career. Do it once, and then just brush up on your skills from time to time. Get into the interviewing mindset and just rock them so you can have your choice of job - and then you can go about your thing once you have the job locked. The up front investment will be worth it!
Things that helped me:
Having trouble with Algorithm design/analysis? These are some of the go-to books for that:
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.
wartex8 mentioned it, but I can't speak about Hacking: The Art of Exploitation highly enough...
This is one of my security starter trifecta:
Hacking: The Art of Exploitation
Rtfm: Red Team Field Manual
Blue Team Handbook: Incident Response Edition
All the code is up on github here, so feel free to poke around. If you have specific questions about the architecture or design I wouldn't mind answering those, but I don't have the time to walk you through everything line-by-line. If you need that kind of instruction I would refer you to the fantastic open.gl tutorials for OpenGL related stuff and a project oriented tutorial-style book like this one for Java for general programming concepts if you're just getting started. I'm not familiar with anything similar for C/C++ but perhaps someone can chime in with suggestions.
I studied for about 4-5 months. I work as an admin now with a little dev experience. Got about an 80-85% on the test. Here is what I did.
For a good beginner book that I think explains things well, look at Headfirst Java.
http://www.amazon.com/Head-First-Java-2nd-Edition/dp/0596009208
Very Good is the book 'Head First Java'
http://www.amazon.com/gp/aw/d/0596009208/ref=redir_mdp_mobile
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)
https://developer.mozilla.org/en-US/docs/Learn/Getting_started_with_the_web/JavaScript_basics
https://www.codecademy.com/learn/introduction-to-javascript
https://www.learn-js.org/
https://www.udacity.com/course/intro-to-javascript--ud803
https://www.udemy.com/beginning-javascript/
https://www.coursera.org/courses?query=javascript
https://javascript.info/
https://www.w3schools.com/js/
https://www.amazon.com/Eloquent-JavaScript-3rd-Introduction-Programming/dp/1593279507
https://www.amazon.com/JavaScript-Good-Parts-Douglas-Crockford/dp/0596517742
https://www.amazon.com/s?k=you+don%27t+know+js&amp;crid=3CTP426AMFRY2&amp;sprefix=you+don%27t+know+%2Caps%2C208&amp;ref=nb_sb_ss_i_1_15
One more to add: JavaScript: The Good Parts
(obligatory joke)
In all seriousness, it is a really good book.
&#x200B;
First of all, don't worry too much about a single interview. A lot of interviewers don't really know what they're doing / why they are actually asking the questions they are asking. Usually, they're programmers--not experts at hiring people.
Having said that, you definitely want to be familiar with common "gotchas" and major issues in the languages/frameworks you will be using.
For JS, I recommend two books in particular: JavaScript: The Good Parts and JavaScript Patterns. I found these helpful because they cover all the major issues with the language and they are quite concise. These don't cover any frameworks like jQuery or Angular though--that's another matter altogether.
Also take a look here: https://github.com/h5bp/Front-end-Developer-Interview-Questions
There's a good chance the interviewers will straight up copy questions from this list and you researching the answers will be a great learning experience.
Don't Make Me Think is an excellent book on UX/UI design.
I'm just about to graduate with my undergrad in CS with a specialization in HCI, and have had multiple UX internships. Read these two books, they'll provide a really good baseline of knowledge about user-centric design.
The Design of Everyday Things - Don Norman
Don't Make Me Think - Steve Krug
While the second one typically focuses more on web, they're both amazing books that should be in the library of any UX/HCI specialist.
The best way to start building a portfolio is to, well, just do. Find anything (not just a program/app, even) that you don't like the design of, and start from there. Try and redesign it to make things easier to figure out. Show it to others to gauge reactions and get feedback. Iterate and improve.
There are a bajillion different programs for UI prototyping, but the first tool I'd suggest is good ol' pencil and paper. Get yourself a sketchbook and keep it in your backpack (or with you in some other capacity) at all times. When you have a design idea, drop everything, make a quick sketch, and go back to what you were doing. Ideas are fleeting and temporary, so it's best to get it on paper before you forget. Once you've got time, try and improve on those designs and think of what would work and what wouldn't. After you're happy (and have shown it to others for feedback), take it into some prototyping app like Balsamiq, Indigo Studio, or Sketch. Render it in high quality and start seeing how users would react to it in its natural setting (put it on a phone, or on a computer, etc. for testing). It's all about getting user feedback because one person on one computer may not have all the right ideas.
tl;dr: Read books. Redesign crappy things. GET A SKETCHBOOK. Feedback, feedback, feedback.
This should get you started :)
Books:
Blogs:
Videos:
Podcasts:
I'm also writing blog posts about getting started in UX Design on my own blog. Check it out. If you have questions or want to know more about a specific topic, just let me know. I'm always looking for more topics to write about.
Edit: Added UX Mag
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.
Here's what's been recommended the past few times this has been brought up.
http://www.amazon.com/Practice-System-Network-Administration-Second/dp/0321492668/ref=sr_1_1?ie=UTF8&amp;qid=1298858799&amp;sr=8-1
I know you didn't ask but I'm going to recommend this book: http://www.amazon.com/Practice-System-Network-Administration-Second/dp/0321492668
I picked up that book and I've been reading it. I've been a sysadmin for 10 years and the book is teaching me things. I'm impressed thus far. It's written the way that I want books to be written.
>I believe I understand the science behind procrastination, but I just can't seem to apply any methods to my life.
Do you have a ticketing system? No. Then, roll a ticketing system with email pickup. OTRS or RT.
If yes, immediately put in place a SOP(standard operating procedure) company wide, that all requests with the exception if critical ops are down, that all requests go through the ticketing system. Back that up with action. With no action, unless it comes through the ticketing system.
>I am the only IT guy at a 80+ user company (which is pretty lax most of the time). Because our ERP software is terrible (Which I didn't choose and constantly argue to get rid of)
You accepted the position and all its responsibilities. Stop trying to change what is and accept that yes you have a POS ERP solution. You're fighting the wrong way. You should be asking yourself how can I make this ERP work for me, instead of fighting to get rid of it.
>I spend most of my time at work generating SQL queries for basic user requests such as order statistics and the like. It turned me into a IT zombie where I procrastinate on all my IT projects unless it's directly in my face.
Can you not automate these procedures? Perhaps scripts users can execute on their own to for order statistics and the like?
> Before I started 4 years ago, I was always reading IT books and going to college and was enjoying learning and experimenting. Now, I almost feel afraid to read about new things or refresh my knowledge because I know I've been out of touch for so long.
You are spending too much trying to figure out the same things day in and day out. You need to start using a ticketing system religiously and start documenting everything. Everything.
> This gives me constant anxiety even while at home, knowing that there are a lot of things I need to work on but haven't in months, such as fully setting up vCenter/vMotion, Configuring the PS SAN array properly, etc. Whenever I try to work on a project, I feel it requires so many prerequisites, let it be knowledge/reading manuals or running out of network ports on a switch, that I'm in a constant juggle of accomplishing nothing.
As munky9001 said you need to let go of work when you leave work. With the policy and ticketing system in place. You can then only respond to operation crit emergencies. Then, when you get in the next day all your open tickets will be in your face to remind you what to do.
> I'm wondering if anyone out there has experienced a sense of losing flow and confidence as a sysadmin and what they did to get back in the game?
Every sysadmin has. You aren't growing enough and just dealing with the same bs. You need to prioritize, organize and document.
The way I attack my ticketing queue:
I also recommend reading:
http://www.amazon.com/Management-System-Administrators-Thomas-Limoncelli/dp/0596007833
http://www.amazon.com/Practice-System-Network-Administration-Second/dp/0321492668/ref=sr_1_1?s=books&amp;ie=UTF8&amp;qid=1344483754&amp;sr=1-1&amp;keywords=the+practice+of+system+and+network+administration
A short version of both, at least read this.
http://everythingsysadmin.com/the-test.html
The Practice of System and Network Administration Second Edition. Filled with great advice. amazon
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.
It depends on what you already know.
&#x200B;
Do you have any prior programming experience? If not, start there. My no. 1 recommendation here would be Allen B. Downey's free Think Python book. Others might come along and recommend something like SICP, which is a good book, but perhaps a bit hard for an absolute beginner. Downey also has a version of his book that uses Java, so if you know for a fact that this is the language your introductory programming class will be using, then that could be a better option (Python is a simpler language, which makes it easier for you to focus on the actual concepts rather than the language itself, but if you know that you'll be using Java, you might as well kill two birds with one stone).
&#x200B;
If you do have prior programming experience, you have all sorts of options:
&#x200B;
Regardless of whether or not you have programmed before, I would also recommend doing the following:
&#x200B;
if you have any questions about my above suggestions, let me know, and I'll see if I can point you in the right direction.
&#x200B;
Good luck!
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 τεχνολογία.
Αν εχεις ποιο συγκεκριμενη ερωτηση πες μου
Not sure about EE-related topics, but for CE you're almost guaranteed to use these textbooks:
And of course, the most important and useful textbook of them all for almost anything coding-related.
I can't really point you to anything online, but this book is one of the best on the subject. If you work your way trough that book, you will know more than most CS undergrads do about algorithms and data structures.
It's also a must have if you're implementing your own data structures every now and then.
>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.
Introduction to Algorithms. It's a great reference book for me now.
These gentlemen above my comment will be the exact answer you are looking for. Especially the save/make money comment. That is job security/advancement/streamlined processes all rolled into a concise statement. Pull information about what you need from UX/UI design, Steve Krug "Don't make me think" with small real world cheaply produced benefits, and also add in the fact of how many hours wasted to the company that the developers are spending trying to update something.
"Don't Make Me Think" by Steven Krug
How E-bay make 300 million dollars by moving a button. Design matters
I've read this book a couple times, technically it is about UI but it helps with how you should layout your page and the reasons why to lay it out that way.
Steve Krug's Don't Make me Think.
https://www.amazon.com/Dont-Make-Me-Think-Usability/dp/0321344758
&#x200B;
You can also torrent it legally.
While data structures and algorithms are important, don't forget design patterns!
Design Patterns: Elements of Reusable Object-Oriented Software https://www.amazon.com/dp/0201633612/ref=cm_sw_r_other_awd_FW0ywbGSR9PB5
more employees = more code = more complex codebase = more bugs.
This is a useful book for understanding what's happening here: https://www.amazon.com/Mythical-Man-Month-Software-Engineering-Anniversary/dp/0201835959
Perhaps.
But that aside, you should always throw away version 1. You now know far, far more about the reality of the situation than you did when you built your MVP.
Also. Go and read The Mythical Man Month.
Doesn't quite sound like what you're describing, but The Mythical Man Month is the book I've most often heard described as absolutely essential for understanding problems with managing software projects.
Introduction to Algorithms is fantastic:
http://www.amazon.com/Introduction-Algorithms-Thomas-H-Cormen/dp/0262033844
Here is my advice, take it with a grain of salt:
If you want to get good at programming, I would recommend the book "How to design programs" combined together with The Racket Programming Language. If you're really up for it, mix in the content from Structure and Interpretation of Computer Programs (which is a great book by the way). If you finished those, you'll have a very good foundation for learning how to program. I would learn a new language (don't specialize in racket) and continue from there.
The downside to learning racket is that it is not a common language, however as I said earlier, you'll find that learning new languages it very easy so this shouldn't be too much of a problem, especially if you're more concerned with forming a good foundation first.
After learning all of that, I would say look into something on data structures and algorithms. There are a lot of great books on the subject. Introduction to Algorithms is considered the classic. If you can get through the whole thing on your own, then you are better then I am.
Yes! Also, quite honestly I don't know that many CS majors who took linear algebra at my school for whatever reason.
Where do you get started?
Bonus for programming:
Maintainable kinda means that your code is easy to test, easy to comprehend (by others) and easy to modify. Read up on different design patterns to learn more about this.
Scalable is something you'll learn more about later, but basically it's kind of thinking about whether your code will be "good" enough to handle a lot of users (how fast is it how much memory will it take up)
Testing is very important when coding. You want to try to write small pieces of code then test it (i.e.: make sure it works).
All three of these things show up a lot in interviews, and if you can relate why you made your code the way you did to one of these three points (or something else) you should be pretty well off :D
How do I land an interview?
How do I study for an Interview?
Typcially, an interview will have you and the interviewer. The interviewer will first ask questions about you, what you're majoring in. And then maybe ask questions about your previous projects, and then he'll throw you a programming problem. Sometimes these can just be questions like "Which is faster: quicksort or mergsort?" or something like that, but other times they'll have you code something. If the interview is online, this will either mean you'll need to tell them the code you're writing or you'll code online on some collabarative envirionment (i.e.: you type the code online). If it's in-person they may have you write on a whiteboard. There are other formats of interviews as well, so make sure to research. Typically, for most larger companies, they won't care what language you code in (hopefully though it's mainstream!), but if you don't code in a language which they use, they may test you later for proficiency in one of their languages.
Sorry, not sure if this helps or not!
Good luck!
Introduction to Algorithms by CLRS. Used in almost every algorithms class I've heard of, and a great reference book. It's about 1300 pages, so don't try to read straight through it.
C Programming Language by K&R. This is a C programmer's Bible.
Design Patterns by the Gang of Four
This is a little more of a topic book, but The Art of UNIX Programming by Raymond.
These are all either pretty common, or almost essential. You'll probably see these in your curriculum anyway, and you should. These are a good cornerstone.
Yes. Everyone should own a copy of: https://www.amazon.com/Programming-Language-Brian-W-Kernighan/dp/0131103628/ref=sr_1_1?ie=UTF8&amp;qid=1494216538&amp;sr=8-1&amp;keywords=c+programming
This. Full stop.
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.
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.
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
Don't rewrite from Scratch: Joel Spolsky goes into detail as to why. Instead, rescue the existing code
I cannot recommend Working Effectively with Legacy Code enough in cases like yours. If done right, you can reach architecture without an end state.
The new way to do this is microservices. If you can properly consolidate your javascript in one place, you can start to break apart the monolith. It's absolutely possible to do in place, and you always have a product.
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 ?
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.
Amazon
Goodreads
Wikipedia
The Pragmatic Programmer http://www.amazon.co.uk/Pragmatic-Programmer-Andrew-Hunt/dp/020161622X
Has a lot of similar stuff to Code Complete 2 but not quite as dense so makes a good primer.
MVC is just a paradigm. Implementations differ from language to language, and some languages have better support than others, but yeah, just a paradigm.
Look into Design Patterns by the (in)famous "Gang of Four" for more information about this.
I will say this -- most experience I have with C# backends leads to great usage of databinding between model and view regardless of application platform (WPF, Windows Forms, even some ASP.NET). And I'm pretty impressed with the support of other design structures that C# and Visual Studio offer with the help of NuGet (looking at you, Angular).
Small employment gaps are no big deal. Over six months people may ask, but it's all in how you answer. I'm not sure why you feel like you're unmarketable having worked in the industry for two years, but do know a lot of the postings - especially junior postings - are inflated. I've seen one that asked for three years of experience with Visual Studio 2019. If you're halfway there, shoot your shot.
As a junior dev, the expectations are low. All I'd expect you to know is how to get code up and running that I don't have to tear down for the good of the company. Be able to read your language and solve simple problems. The biggest thing I look for in a junior dev is if I can give them some piece of of the software to write while I'm not looking and feel that you're mostly there when I come back to check. Apply for appropriate positions and don't fudge your experience. Enthusiasm and eagerness to learn go a long way. Don't be a know-it-all from your position.
Decide what kind of role you'd prefer, and start the process of brushing up on that. Use the job postings that represent the jobs you want as direction on what you need to learn. If the role you really want is too far, get a job doing what you know to pay for your education in the role you want.
As a front-end developer, you're going to want to learn a Javascript toolchain and one modern framework to start. Npm and Node.js are the backbone of what you do. If you want to switch, learn what juniors do in that paradigm. Do know that the Javascript world is fast-paced and fad-based, so if you miss a wave, wait two years and the next one will be coming around for you to hop on.
Personal projects are a good idea, just make them meaningful by using the proper setup (not just some bullshit hack job) or address an interesting problem. You're going to want to get it up on a personal repository that you can put a link to right on your resume and job site (Indeed, Dice, Glassdoor, Linkedin) posting. Be able to speak to every decision you made, even if it was a bad one. Your personal project doesn't have to be spotless or even completely done, it just has to be yours, it should be able to execute, and you should show some decent decision making. A mod for a game, a contribution to open source, a personal thing that has some use-case or whatever.
Get experience with related technologies. Start to learn one step before and beyond the one you're a specialist in. For example, you're a junior front-end dev. Learn a little about backend work, and learn about deployments. Learn about the experience of your fellow team members as they try to integrate your work with Git, build with Jenkins or AWS Code Build, and containerize with Docker. Think about the pain points you face in architecture, code, building, and deploying; think about how you'd solve them or if you can't, keep an eye on solutions as you go. Know the differences between elements of your chosen sphere.
Higher level concepts like SOLID principles,Design Patterns, and Refactoring Patterns are more goals than expectations, but you should take a look at them now and at least be able to speak to at least one of them somewhat. With limited time, prefer Design Patterns. You don't want to walk into an interview where someone asks you about how you use design patterns and you've never heard of them. Even if they'll accept that, you still won't feel good about it.
Look up some materials on coding challenges, as some companies give coding quizzes. I just had an interview with a guy that touted 10+ years of experience but couldn't read from a file given an hour.
If you feel like you're going to be let go due to performance, get ahead of that and ask your supervisor how you're doing or what you need to do to grow. If you feel like you're going to be let go due to a restructuring you can't affect, you have two options: get to know other teams so you can maybe hop on their project later, or just save your money and get to work on some of the stuff above each weekend until the axe falls. You're a junior dev. You're not expected to be perfect, but you should come in a teachable state - some foundation with programming, a willingness to learn, a willingness to figure things out, and the ability to take direction.
Design Patterns (aka Gang of Four)
https://www.amazon.co.uk/Design-patterns-elements-reusable-object-oriented/dp/0201633612
Download:
Notepad++
MinGW GCC
Buy/Borrow/Download:
The C Programing Langiage
The Standard C Library
Read:
Answers To Exercises
Computer Science For Everyone
C Tutorial
Practice.
Profit.
Got a Question?
Learn 'C' and 'Python'.
'C' is the lingua-franca of computers.
Start with K&R's 'The C Programming Language'.
Python as a high level language for getting things done. 'Dive into Python' is a good start.
Io direi di iniziare con il C.
Il manuale che consiglio(io) è, solamente, questo:
The C Programming Language: ANSI C Version
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.
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
First of all, this is an excellent post. I've seen so many questions posted here but yours is the most concise and upfront. I know exactly what your background is and so I'm more confident that what I want to suggest would actually be relevant.
You have solid industry experience with academic foundation. And I think you already are aware of the pitfalls of expert beginner (http://www.daedtech.com/how-developers-stop-learning-rise-of-the-expert-beginner/). I think you are in a sweet spot where you can afford to invest resources without immediate gain - unlike early-career coders, you don't have to necessarily learn another language/framework right this second. You can afford to deepen your higher-level understanding of concerns and concepts that are timeless and not bound by the language/framework of the day.
I'd like to suggest you read other people's code/design. Here are some books to get you started.
Another thing you can invest in is everyday skills as a programmer. This is a classic on this subject.
You can couple ideas and tricks from here with any devops tools of the day to automate much of your workflow, such as bash/git/unix concepts onto automation tools such as docker/jenkins/ansible. Additionally, familiarizing/customizing your personal development environment. Improving scripting skills to automate many many things (practically everything that we do on computers that doesn't involve creative process are automatable. It's just a matter of ROI.).
> Knowing one programming language, is of course, a must for any sort of programming. Knowing many programming languages is a bit less important, in a way. Many languages are very similar to one another and aside from the keywords, the syntax largely remains the same. If you've done Java before, then this means you could very well hold your own in C++, C#, and VB.NET for example.
I'd disagree strongly on this one. Writing VB.NET is very different from writing C++. I'd argue that programming language paradigm is more important. It's easy to switch between languages following the same paradigm because, beyond frameworks, libraries, and syntax, they are very much the same.
>Whenever possible, seek to make your functions about a screen's height. It's easier to follow the flow if you don't have to scroll up and down all the time.
Huh? That's a weird way to explain it. What's more important than number of lines is the Single Responsibility Principle. Every contextual item in your program (class, method, variable, etc) should only have one responsibility.
Otherwise I'd agree with this advice. For these little quips like these check out The Pragmatic Programmer, which is perhaps one of the best books that helped me move from a novice/junior developer to an intermediate/senior dev.
I'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
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
As far as engineering practices are concerned: Clean Code, Clean Architecture. A secure app/arch is one that is well understood long after you've stopped working on it.
DefCon has a reading list:
https://www.defcon.org/html/links/book-list.html
If you're looking for a starting point, I'd suggest The Tangled Web. Web/browser security tends to be a good high-level starting point.
You asked for books, but I'd highly suggest participating in some CTFs.
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 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.
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 :
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 learned it from this book around 25 years ago:
https://www.amazon.com/Programming-Language-2nd-Brian-Kernighan/dp/0131103628
But you can probably save the money and just use any tutorial on the internet. I'd recommend just starting out with C++ though. When object oriented programming went mainstream, I had a lot of trouble switching over to the new mindset. You're better off learning OO from the beginning.
Just learn C. There are tutorials all over the place, or you can buy http://www.amazon.com/The-Programming-Language-Brian-Kernighan/dp/0131103628
ATLien325's comment explains that terminology in a pinch, but it's not really going to get you very far on your way to learning how to hack. Your best bet would be to pick up books like this, this, and this. Then you'll have an idea of how programs, file systems, and networking work behind the scenes and you are much better situated to begin to learn how to hack them.
You're also going to need to learn how to effectively use a search engine.
I have been working through C Language: 2nd Edition have been having a few problems understanding a few things but good book!
I had no real programming experience before I started C as part of a university course. Thankfully, my first course was on the language itself so the problems were all based around understanding the fundamentals of C itself (not on the theory of algorithms).
I know some people here are criticising it as a first language choice, and I'll admit that I am in two minds about recommending it. However, I'm struggling to think of a better choice.
So I'll assume that isn't up for debate or maybe even the class recommends it?
Unfortunately I have never taken a relevant MOOC in this area. I have looked at several books however:
I can't avoid mentioning The C Programming Language by Kernighan and Ritchie aka K&R - if only to say I dont recommend it. I own a copy and feel its not really appropriate for a complete beginner. Its not a book you can sit down and read through. Its basically a reference manual, to be used to help provide context for a particular problem. Unfortunately, at the start I would know what I wanted to achieve but didn't know the correct terminology to describe it, in which case the index becomes useless (even Google can't work these types of miracles).
Absolute Beginner's Guide to C by Greg Perry is however very readable. Its probably a little too verbose for someone who has prior programming experience - as the title suggests its written for the absolute beginner. It should be ideal for you however. If you are prepared to go for a book rather than a MOOC I highly recommend it.
The C Programming Language
If you want to learn C - you should read K&R's The C Programming Language (the bible for C) and do all the exercises.
Also - the first half of CS50 is in C. r/cs50
Buy K&R and do the exercises.
You may also find /u/_Madk's list of projects interesting. It focuses a lot of games, if you're into that. A lot of those are pretty easy to show to non-programmers, which is always nice. (ex. Dad can appreciate Tetris more than your Red-Black Tree)
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.
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
[here is a fantastic book every programmer should read] (https://www.amazon.com/dp/0132350882/ref=cm_sw_r_cp_apa_kt9TAbN9RY2S3)
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?Maybe this will help.
https://www.amazon.com/Pragmatic-Programmer-Journeyman-Master/dp/020161622X
Seconding The Pragmatic Programmer and Cracking the Coding Interview. I'd also recommend:
If you let us know which languages you primarily write, I can probably recommend some good language-specific titles, too.
The Pragmatic Programmer: From journeyman to Master. It's a philosophical book that shares wisdom on how to think like a programmer. . . Not in the pure sense making you a better Computer Scientist (in terms of thinking algorithmically) but if you write code you should give this one a thumb through.
I can't speak of a specific book that is a comprehensive history of computing, but I will speak to books that speak of our culture, our myths, and our hero's.
Hackers and Painters, by Paul Graham. People are polarized about the man, whether he's too "pie in the sky" - full of shit and ego, or if he speaks as an ambassador to our most optimistic ideals of our (comp-sci) culture. The contents of this book is a collection of his essays that are inspirational. It made me forego the societal pressures within our culture and reject popular opinion because it is merely popular and just an opinion, which is a virtue no matter who you are, where you are, or what you do. All these essays are on his website, though. If you want to review them, I recommend Hackers and Painters (the essay), What You Can't Say, Why Nerds are Unpopular, and The Age of the Essay; his oldest essays are at the bottom of the page and go up - he writes about what he's thinking about or working on at the time, so you'll see the subject matter change over time. So much of this will have direct application to his middle school and high school life. I cannot recommend this book, and the rest of his essays, enough.
If he wants to get into programming, I recommend The Pragmatic Programmer. This book talks about the software development process. I'm not going to lie, I don't know when best to introduce this book to him. It's not a hard read whatsoever, but it's abstract. I read it in college in my first months and said, "Ok," and put it down. Approaching the end of college and my first couple years in my profession, I would reread it ever 6 months. It's a kind of book that doesn't mean anything, really, without experience, without having to live it, when he has an obligation to his craft, his profession. I tell you about this one since you're asking about books to tell him, because this isn't something someone would normally come up across without being told about it.
The Cathedral and the Bazaar is a telling book about the cultural differences between the proprietary monoliths like Apple and Microsoft, and the Free and Open Source Software communities that back such popular software as Linux (the most popular operating system on the planet, running on all top 500 super computers, most server computers on the internet, and all Android phones) and Chrome(the worlds most popular web browser). Indeed, this book directly reflects the huge cultural battle that was duked out in the field, in the industry, and in the courts from the mid-90s and into the 2000s. It advocates helping the community, contributing to something larger than yourself, and that none of us are as good as all of us. To paraphrase Linus Torvalds(inventor of Linux) "Given enough eyeballs, all bugs are shallow."
It's important to know who the hero's are in our culture, and they are diverse and varied, they're not just computer scientists, but mathematicians, physicists, philosophers, science fiction writers, and more. I would find a good book on Nicola Tesla, since he invented basically everything anyway (Thomas Edison was a great businessman, but a bit of a tosser), Richard Feynman was a physicist who is still celebrated in his field, and he even worked for Thinking Machines, back in the day, which was a marvel of it's time. Seymour Cray founded Cray Supercomputers and they have a lasting legacy in the field, a biography on that would be interesting. A biography on Symbolics and their Lisp Machines will make him yearn to find one still functioning (a rare gem that crops up every now and again, though he can run one in an emulator), and about the "AI Winter", a significant historic era (note: the AI Winter is over, and we are in spring, the history is both compelling and enthralling). Anything Issac Asimov published (in nearly every category of the dewy decimal system) is also compelling, and hardly dated. In fact, he's the originator of a lot of modern sci-fi. Charles Babbage invented the modern computer (though it was entirely mechanical in his day, and it wasn't actually built until 1996-2002) and Ada Lovelace was the worlds first computer programmer. A woman! Speaking of women, and it's worth young men learning this about our history, Grace Hopper was a military computer engineer who invented the term "bug".
And speaking of women, someone I have respect for, especially if your boy wants to get into game development is Sheri Graner Ray's Gender Inclusive Game Design, which may be more appropriate when he's in high school, and I consider it required reading for anyone who wants to enter the gaming industry. The book lays out plainly how video games hyper-sexualize both women, and, for some reason surprisingly to many - men, it's disastrous effects it has for the game industry, the game market, and the gaming community, and insights on how we may combat it. I have seen colleagues (men) become indignant and personally offended at reading this book, but were absolutely humbled when they took the fight to Sheri directly (we had a few phone interviews with her, always fantastic). If your boy found a problem with this book, he would do well to read Paul Grahams essay on keeping his identity small... The subject matter is not a personal attack on the individual, but on the blight, and he would be better served finding himself on the right side of history with this one, it would serve him well if he were to pursue this craft, specifically, but also any forward facing media in general.
And I also recommend some good books on math. Algebra, linear algebra, calculus, and statistics. You can get very far, lead an entire career unto retirement without knowing anything more than arithmetic and basic, basic algebra, but he could only serve himself well if he makes the decision that he is going to like maths and chooses to willfully become good at it. Outside the context of school and terrible teachers, it's actually an enthralling subject. Just get him a copy of Flatland, Flatterland, and Sphereland. Try this. There are books about proofs that break them down into laymen terms so that anyone can celebrate how special they are. My wife has a few on the shelf and I can't remember their titles off hand. Also this, the book is the narrative of some witty laymen who discover a whole branch of mathematics from first principles, the surreal numbers, an extension of imaginary numbers. It's really quite good, but might keep him occupied for a couple years in high school.
I should stop here or I never will.
The Pragmatic Programmer: From Journeyman to Master
It's not really focused on Java or any language specifically, but it helps you become a better team member. The concepts help you write code you won't curse at later...
https://www.amazon.com/Pragmatic-Programmer-Journeyman-Master/dp/020161622X This is a book I usually advise junior developers to read. Another one is Clean Code by uncle Bob.
So this is what I would consider the "Core" reading list for anyone interested in programming games. None of this is really game specific though. These are just the fundamentals you need in order to be an effective Software Engineer.
Learn about...
C++ syntax: Programming: Principles and Practice Using C++ by Bjarne Stroustrup
Software Engineering: Code Complete by Steve McConnell
C++ gems: Effective C++ by Scott Meyer
Software Teams: The Mythical Man-Month by Frederick P. Brooks Jr.
Why we love Joel: Joel on Software by Joel Spolsky
Problem Solving: The Pragmatic Programmer by Andrew Hunt
Common Code Solutions: Head First Design Patterns by Eric Freeman
Pearls!: Programming Pearls by Jon Bentley
I'll do a supplemental on this in a few days that dives into specific topics related to engine development. All of this is generic enough that it will help you regardless of what you do. You'll notice that very little here is actually language specific. Almost all of this is about the art of making software and process of working with a team. These 8 books alone will make you think about making software in a whole new way.
The Pragmatic Programmer
I should re-read for a refresher. Invaluable source of general information that can help any type of computer programmer, regardless of their language of choice.
The Pragmatic Programmer (http://www.amazon.com/Pragmatic-Programmer-Journeyman-Master/dp/020161622X). It's a great resource to help you think about your career and how working as a software developer is different from what you learn in school.
Read The Pragmatic Programmer
It is exactly what you're looking for.
You have to under the concept of uncoupling your programs and break them up into separate entities and that takes practice. This book will show you a few main guidelines to follow but without application you will not get pass that wall.
Don't want to bullshit anymore? put yourself in a position where you can't bullshit. Get a job as a webmaster, it's not very hard. Smaller non-technical companies would love to hire college kids to build an internal inventory tool or something that they can use.
For language specific stuff like c++ I'd suggest:
https://www.toptal.com/c-plus-plus/interview-questions as a pretty good quick review. Going through c++ primer (or whatever book you learned C++ from) and just touching on all the topics that you don't remember can help a lot.
What helped me with design patterns is head first design patterns. Even though that book seems very 'intro' it has helped me pass all the design pattern question I've ever gotten. I think just visitor, singleton and MVC are the most popular interview design patterns. The more canonical 'gang of four' book would be: this.
For just practice tech interview problems that you'll see on silicon valley, big4 tech interviews, the most popular site is probably leetcode (hackerrank, or top coder or even codewars are pretty good sources too). The most popular book (as mentioned many times) is Cracking the coding interview.
Just grinding out problems on leetcode, you'll probably learn enough to pass most tech interviews after about 100-200 questions (if you've never done this before, less if you have).
Before/during your leetcode practice I've written a series of tech interview tips to help you check on your fundamentals (you can check it out at fizzbuzzed.com). I try to go over the questions I see people failing most often. I'm also trying to help readers so would love to help you if you run into problems.
I also think you should ask the recruiter the style of interview you'll be having. If you are on the whiteboard then you should practice on it before hand (whiteboard interview tips here.
Here are some books that I feel have made me better professionally. They tend toward the comp sci side, some are more useful than others.
Lastly, find some open source projects and read their papers, then read their code (and then the paper again, then the code...etc)! Then find their blogs and read those too. Then find them on Twitter and follow them. As others have said, the field is evolving very quickly, so half the battle is information sourcing.
Okay I came in to school like you with very little programming experience. Probably even less than you since I only messed around on my TI. I am going to assume you're only taking ECE110 first semester. If not I recommend getting in as soon as you can. They may give you some crap about it depends on last names, but it doesn't really matter. After a certain point its open to everyone.
Either way, programming in ECE doesn't really start until you take ECE190 which is all C programming and a very simplified assembly language for educational purposes. Like I said I went into the class with practically zero programming experience and still did very well in the class, so don't let anyone scare you on that. If you put the time aside to read the book (really helpful in 190) and doing your MPs/ask the TAs questions you will do fine.
I wouldn't fret too much over the summer with learning stuff, but I would definitely recommend C over Python. Python is pretty easy to pick up, but its also very high level. If you need an introductory language to get familiar you can try python for a bit, but I'd go with C after that. It is worth noting that the other two required programming class you have to take (CS 225 and ECE 391) are C++ and C/x86 respectively. So learning C should definitely be your focus.
I recommend the book written by the creators of the language. The book the school requires is pretty good too actually and would give you a better idea of what to expect. They're kind of pricey, so its your call how you want to get them. As a heads up, codecademy does have Python, but not C as far as I recall. I've never used lynda do I can't comment on them C Book ECE 190 Book
I honestly wouldn't fret too much about it all. Enjoy your summer, depending on how busy your schedule is next semester you can probably set aside some time now and then to study some languages. If you have any more questions I'd be happy to answer.
"the" C book: http://www.amazon.com/Programming-Language-2nd-Brian-Kernighan/dp/0131103628
K&R is the go-to C book, IMO.
Read "The C Programming Language" ( https://www.amazon.com/Programming-Language-2nd-Brian-Kernighan/dp/0131103628 , it's also on libgen)
&#x200B;
Make sure you're cool with data structures (most of them are important, but hash tables are very key because they form the basis of caches, something you'll have to learn)
&#x200B;
Look up some basic digital logic (up to flip-flops and d-latches, and cover some FSM too if you have time)
&#x200B;
I don't really know of any great resources to self-study assembly, so you'll have to just make the most of the lectures on that.
&#x200B;
Prof Nagarakatte is super fair imo. Multiple project extensions, a multitude of extra credit opportunities (I believe it totaled to something around 15% of the total course grade with max extra credit when I took it), and no curve- you just need an 85% (after extra credit is applied) to get an A, which is nice. The best thing about him, though, and something I've never seen anywhere else, is that the TAs know what they're doing. He tries to get his own grad students TA positions, and so he's got a great working relationship with them. Go to recitation, because the TAs know what's up and will often write out significant portions of the projects for you. In my opinion, the course wasn't particularly easy, but an A is definitely achievable as long as you put in the effort. His lectures are pretty fast, but the slides are online and fairly self-explanatory, so try to go over them after each lecture if you can.
Haha, sorry it is a commonly referenced book I did not even think about it.
Brian Kernighan and Dennis Ritchie (early developers / creators of UNIX) wrote a book called The C Programming Language. Make sure you get the second edition though.
I used Head First Java. It's actually a pretty funny book and helped me get all the OO concepts down really well. Very easy read.
I like the book Head First Java if you have some programming experience. If you need something more basic (actually it's probably very similar to your class), Stanford has their Intro to CS class online here. It's in Java, and the teacher is pretty entertaining.
I think Head First Java is a good book for beginners.
Head First Java contiene l'introduzione agli oggetti più semplice e carina che io abbia letto. Però è in inglese, e non è stato tradotto. D'altro canto ti devi arrendere: l'inglese è un requisito per imparare la programmazione. La quantità di materiale nelle due lingue è semplicemente non paragonabile.
I don't know how far you are into your academic career, but here's a pro-tip/lifehack from someone who got through a master's degree in an unrelated discipline: If the professor doesn't require the latest edition (just ask them), don't get the latest edition. Get one or two editions back, if they're not super-old, and the $25 2011 edition or the 32 cent 2008 edition are probably more than adequate for an introductory book. Hell, the most referred to book (one I love) -- Head First Java, 2nd Edition -- is from 2005, and it's still relevant even if it doesn't cover the most recent language developments.
It's very rare that a college book for anything other than highly advanced courses or cutting-edge technology will have anything necessary in the most recent editions. I don't know how many thousands of dollars I saved over my academic career buying two versions back, and never personally encountered a single problem since the majority of what they do is reorganize pages, add a graph, and call it "9th version" or something. I took a few books and did side-by-side comparisons and have never found anything worthy of $100-200 price tags versus $3 or less -- most often things like a picture moved to the opposite page or an updated index.
Again, this is most especially true for beginner courses, and you should always talk to your instructor. But in the off-chance anything is missing, you can just ask a classmate to read the relevant chapter from their book.
But for an unrequired side book, it's hard to justify spending $100+. Maybe try the 2008 edition while googling newer features, or take a look at Head First Java (great introductory book, in my opinion).
I highly recommend checking out the You Don't Know JS book series by Kyle Simpson. It goes in depth into how the language works and all the quirks you might encounter: https://github.com/getify/You-Dont-Know-JS
If you'd like a shorter read and maybe have your opinions formed for you... checkout JavaScript the good parts: https://www.amazon.com/_/dp/0596517742
You should probably start with this book called Code and work your way up from there. It's actually pretty hard to find a single book that describes the history and the concepts, and even if you did find one, most of the topics would be hard to grasp on a first read. Code is usually a great starter book and might give you a few pieces of what your looking for. After you finish it, maybe check out a software book and dive into some of the concepts.
All of these answers answer your question on a general level, but I would really recommend reading Code: The Hidden Language of Computer Hardware and Software by Charles Petzold for a deeper understanding. He talks about how the first computers were built and how they were programmed, and he does it in a way that's understandable even to a person that doesn't know a thing about computers.
If you don’t want to real an actual textbook, this one will do the job (without skimping on details) and is more laypeople friendly:
https://www.amazon.com/Code-Language-Computer-Hardware-Software/dp/0735611319
Just as an aside, I had a non techy friend who had a similar sense of mystification as OP’s but really wanted to understand them better, so I pointed him at this book. The next time I saw him we had a great conversation about logic gates and data representation. So it works! It was actually almost a cathartic experience, taking a person who doesn’t get to someone who does, since as a developer you often have to deal with users who don’t know and don’t care.
It's so great you're being so proactive with your learning! It will definitely pay off for you.
I like other's suggestion of Clean Code, but I fear as a first year that it may have mostly flew over my head--not that it would at all hurt to read. For a first year student specifically, I'd recommend either of two books.
Structure & Interpretation of Computer Programs, also known as The Wizard Book and free on the link I just sent you, is a famous textbook formerly used in MIT's Intro to Computer Science course. However, it's conceptually useful to programmers on any level. If you really, seriously read it and do the exercises, it's gonna give you a rock-solid foundation and shoot you ahead of your peers.
It uses Scheme, a quote-on-quote "useless" programming language for any real-world purpose. That's arguable, but the important thing about the book is that it's really edifying for a programmer. The skill it helps you develop is not the kind that will directly show on your resume, it's nothing you can point to, but it's the kind of skill that will show in your code and how you think and approach problems in general. That said, the book has exercises and the MIT site I linked you to has labs that you could potentially show off on your github.
Code: The Hidden Language of Hardware and Software is much more approachable, is not marketed specifically for programmers, and does not contain any exercises. Read it, though, and you'll find you have a huge boost in understanding the low-level computing classes that your classmates will struggle with. What is basically does is show the reader how one can build a computer, step by step, from the very basics of logic and switches. It's readable and written for a casual audience, so you may find it easier to motivate yourself to finish it.
SICP and Code, despite both being extremely popular, can be a bit difficult conceptually. If you don't fully understand something, try reading it again, and if you still don't understand it, it's fine. Everyone experiences that sometimes. It's okay to move forward as long as you feel like you mostly get the topic. Don't let the perfect be the enemy of the good.
Best of luck to you, and be excited! It's thrilling stuff.
https://www.amazon.com/Code-Language-Computer-Hardware-Software/dp/0735611319
This is a great start, as it explains and goes into great detail regarding cpu/gpu architectures: Computer Architecture, Fifth Edition: A Quantitative Approach
Another one that goes to low level is: Code: The Hidden Language of Computer Hardware and Software
>"He starts with basic principles of language and logic and then demonstrates how they can be embodied by electrical circuits, and these principles give him an opening to describe in principle how computers work mechanically without requiring very much technical knowledge"
-wiki
If you would like a really in-depth explanation, check out Code.
Petzold's Code: The Hidden Language of Computer Hardware and Software. Fascinating book about logic gates, character encoding, and so on.
I would this in a top level comment but it’s against the rules of the sub to do so, but OP can check out this book, called “Code” is a great, truly ELI5 intro to computers. If someone is interested they can check it out.
https://www.amazon.com/Code-Language-Computer-Hardware-Software/dp/0735611319
Great book, I highly recommend it
Patternson's Computer Architecture: A Quantitative Approach was a pretty good book. I remember mostly teaching myself from that textbook since the prof I had wasn't a great lecturer.
You can probably find a PDF of it online easily enough.
EDIT: If you want a reasonable sized book instead of a big textbook, I'd recommend reading Petzold's Code, it's a fun read.
First, there are two requests: one from your title, and one from your description. The request from your title is a bit easier, though I'm afraid I won't be able to answer it satisfactorily. As far a real world example, that may be a bit harder because modern CPUs are pretty complicated. (When I was learning computer architecture at university, we never really discussed how an intel or AMD cpu worked -- just learned about the MSP430 and a couple of hypothetical CPUs. If you really want to see how a real CPU works, I'd suggest looking into a microprocessor to get started.)
A quick and dirty summary for MIPS CPU datapath Computer Organization and Design 4th ed page 315:
Note that the MIPS example doesn't use pipe-lining, which generally makes things a bit faster. And there's only one code path executing. And there's no look ahead. Which isn't the case for modern CPUs.
For further reading I highly recommend Code by Charles Petzold. I think it helped prepare me before going to college (for computer engineering).
For video learning, a quick google search shows some videos that would probably be helpful (I haven't watched any of these).
Sorry for the rushed response, I can expand on this more later if there's interest.
I liked it. I would also recommend reading CODE: http://www.amazon.com/exec/obidos/ASIN/0735611319
Between MIT's Python course, CS50 and that you'll have an excellent grounding in CS
That depends how adept you are at programming in general and what you want out of the book. If you have experience with other languages you could get by with a cheaper 'handbook' or just visit cplusplus.com. If you want a more comprehensive 'how to program' book I would suggest reading the definitive C++ book guide and getting yourself a copy of Code Complete.
http://www.amazon.com/gp/aw/d/0735619670 code complete. One of the best books about coding in general that I've ever read.
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.
Theres a book callee HTML/CSS HTML and CSS: Design and Build Websites https://www.amazon.com/dp/1118008189/ref=cm_sw_r_cp_apa_i_WwD1CbAZFSF55
Ok I actually understand this, because I took Computer Systems and had to read http://www.amazon.com/Hacking-The-Art-Exploitation-Edition/dp/1593271441. This is awesome.
I was personally recommended by my mentor Hacking: The Art of Exploitation, and The Web Application Hacker's Handbook: Finding and Exploiting Security Flaws
Also some companions sent me some readings on index articles. I'm not so sure of the titles, but just browse around.
http://slav0nic.org.ua/static/books/
http://hackbbs.org/article/book/
Hofstadter's Gödel, Escher, Bach
If you like things a bit more prose-y, try Pirsig's Zen and the Art of Motorcycle Maintenance
Not specific to algorithms or even to CS, but Douglas Hofstadter (Gödel, Escher, Bach, I Am a Strange Loop) touches on many of the logical fundamentals in a relatively layman-digestable manner.
I wouldn't call him easy reading compared to Sagan or Kaku, and don't know a "pop computer science" equivalent to those two, but you definitely don't need a CS or math degree to get through GEB. Whether it's on-topic enough here is definitely questionable.
---
Edit: I haven't read it, but from the description this one by Thomas Cormen looks like it might be close to what you're looking for: Algorithms Unlocked.
"This is a unique book in its attempt to open the field of algorithms to a wider audience. It provides an easy-to-read introduction to an abstract topic, without sacrificing depth."
From the TOC, it looks like it's probably fairly light on math but gets into code or pseudocode relatively quickly. I still wouldn't call it pop-CS, but if that sounds like a fit, maybe give it a shot!
Go read Godel Escher Bach
Here's the inevitable recommendation for Gödel, Escher, Bach (Amazon page, so you can see the reviews).
Synopsis:
>Twenty years after it topped the bestseller charts, Douglas R. Hofstadter's Gödel, Escher, Bach: An Eternal Golden Braid is still something of a marvel. Besides being a profound and entertaining meditation on human thought and creativity, this book looks at the surprising points of contact between the music of Bach, the artwork of Escher, and the mathematics of Gödel. It also looks at the prospects for computers and artificial intelligence (AI) for mimicking human thought. For the general reader and the computer techie alike, this book still sets a standard for thinking about the future of computers and their relation to the way we think.
>Hofstadter's great achievement in Gödel, Escher, Bach was making abstruse mathematical topics (like undecidability, recursion, and 'strange loops') accessible and remarkably entertaining. Borrowing a page from Lewis Carroll (who might well have been a fan of this book), each chapter presents dialogue between the Tortoise and Achilles, as well as other characters who dramatize concepts discussed later in more detail. Allusions to Bach's music (centering on his Musical Offering) and Escher's continually paradoxical artwork are plentiful here.
It may be strange, but during the biology and nature-of-thought-related sections of GEB I decided to read the neurology chapters of Gray's Anatomy (no, not Grey's Anatomy). It's pretty heady and slows you down quite a bit, but it results in a really interesting mix of deep biological knowledge about the structure of neurons and functioning of the nervous system with GEB's higher-level, cognition-focused discussion.
Note that that's the 40th, British edition of Gray's Anatomy. There are cheaper ones if you don't need the most up-to-date version, including leather-bound reprints of the classic 1901 American reprint. I doubt the old versions have much accurate information about neurology, however.
In today's shiny web world, it can't hurt to learn JavaScript, but it's a dreadful mess, saved only by this fine book.
Python is a great language for learning, and I think Tasker supports it..
Now, I've spent years in software, and I suggest you stick with Tasker and its plugins, because it is very well thought out. You can learn a lot about real world stuff if you focus on being battery efficient and being responsive. Setting task and profile priorities, scheduling waits, running tasks in parallel, is an art.
Premature optimisation is the root of all evil in programming. JS doesn't necessarily make things faster, and believe me I've seen clueless JS programmers consider using C/C+ for speed, when they could have simply used JS properly. Use libraries, not DIY code, which is why AutoTools is so good.
JS is hard, especially for people new to programming. Basically, JS as we know it today is an evolution of a browser hack that only recently became a seriously useful language. The syntax is terrible, math and numbers don't make any sense, the regex system isn't super robust, oh and it's not really an OOP language. Technically, it is multi-paradigm and includes some oop-like things and classes are on the way to browsers, but it's for naught anyway, because you don't need classes in JS - It's a prototypical inheritance based language.
If you're new to programming in general, I'd say you should start with a more sane environment, like Python. It will teach you programming concepts while railroading you into making good coding decisions. It's really common for people to start with Learn Python the Hard Way - don't. Go to /r/learnpython and search "LPTHW 31" and just count up the people struggling with it. Zed Shaw is an idiot, there are better things to read, I'd recommend watching the google IO talks, get a buddy to learn with. Honestly, I've never read a python book cover to cover, but I feel pretty comfortable with the language from just googling "How do I do X in Python" millions of times, usually if a link comes back to docs.python.org, I click that one first. The docs are wonderful, you don't need a book.
But, since JS is one of the most important languages due to it's integration with the most common form of media distribution in our time, I'd recommend reading / watching talks by Douglas Crockford. Check out Javascript: The Definitive Guide and Javascript: The Good Parts. The second one is a little easier to digest, while the first is really the definitive guide.
In both cases, I'd recommend doing the challenges on hackerrank.com.
Crockford's JavaScript: The Good Parts.
Serious recommend.
I've been using node for about a year now (was a PHP/mySQL dev for 6 years before that) and have come to realise that it's all about methodology. The language is just JS (I mean, you should get good at JS too) but it's how you use it that defines whether your node code will be good or not.
Some things I've found useful:
My experience:
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!
If you're interested to learn the basic physicality of a computer, I'd recommend checking out a book by Charles Petzold: "Code: The Hidden Language of Computer Hardware and Software."
https://www.amazon.com/Code-Language-Computer-Hardware-Software/dp/0735611319
It's easy to read and provides a lot of insight into how circuitry embodies and propagates information!
Code
For the 'computers in general' side of things: Code: The Hidden Language of Computer Hardware and Software
I cannot recommend the book Code by Charles Petzold highly enough. This is the book that solidified my love of computer science and hits most of the major topics in CS in an easy to understand and thoroughly entertaining way. By the end of the book you have walked through the fundamentals of how to build and program a rudimentary computer and had fun why doing it!
http://www.amazon.com/Code-Language-Computer-Hardware-Software/dp/0735611319
I'm assuming you just want to learn the basic information about how computers work and the principles behind programming them, right?
In that case, I'd recommend Code by Charles Petzold
Are you looking to actually learn how to program and write code in a specific language? If so, then I'd recommend Automate the Boring Stuff with Python by Al Sweigart. It covers the basic principles of writing functions and how computer logic works, and you'll actually be able to apply it to some practical uses. And since its Python, it'll run on a lot of different platforms. If you like it, you may want to get into working with the Raspberry Pi. Javascript is another good language to start with, but as a book, I really like this one.
If you already know a bit about programming, and just want a general reference book, then Computer Science Illuminated by Dale and Lewis is pretty good.
You should give this book a read Code: The hidden Language Of Computer Hardware and Software By Charles Petzold
It does a great job of explaining how it all works. Loved it and I don't know how to program (Yet).