Best products from r/AskProgramming

Heh, sure.

A lot of people are fans of Code Complete. I tried reading it after being in industry for a decade, and I found it to be very dry and boring. The general consensus from people that I've talked to is that it's more useful when you're just starting out. Maybe I just came to it too late.

A better book (in my opinion) in that same vein is Clean Code. Clean code is shorter, more focused, and has better real-world examples. It feels less "complete" (hue hue) than Code Complete, but to me, that's a strength. As a quick point of comparison: Code Complete devotes 32 pages to the chapter on identifier naming; Clean Code devotes just 14.

I got a lot out of Design Patterns. I seem to recall that the pattern fad was in full swing back when I read this in 2005-ish. I think I had independently discovered some of the patterns already at that point, but this book helped me to codify those ideas and also showed me some new ones. Some of these patterns are now seen as antipatterns (I'm looking at you, Singleton!), and all of the patterns have an object-oriented bias. But there's still something useful in the pattern language, and this book is a reasonably comprehensive start. The book is somewhat dry, and some people report that Head First Design Patterns is a gentler and friendlier introduction. Head First Design Patterns hits the essential patterns, but misses a lot of the less popular ones.

Eventually, you'll need to work in a codebase with some technical debt. Maybe it's debt that somebody else put there, or maybe it's debt that you introduced. Working Effectively with Legacy Code is still my go-to recommendation. It defines technical debt as code that is not under test, it introduces the idea of "seams" that you can use to pry apart code that's too tightly coupled, and it then provides a cookbook of specific scenarios and reasonable approaches.

If you're looking for thought-provoking videos, I recommend anything by Rich Hickey. I don't know if I've watched all of those, but I remember good things about Hammock Driven Development and especially Simple Made Easy.

Get comfortable with a source control system. I didn't use source control in college, since it wasn't needed for any classes, and that was a missed opportunity. The whole world loves Git, so you'll probably want to learn it if you haven't already. But I'll also toss out a recommendation for Mercurial. I haven't used it in years, but I remember finding it to be quite good.

Good luck!

One of the biggest issues I see with some of the dev's I work with is that they easily get lost in their work. We refer to it as shaving a Yak. Let's say you need to go pick up some milk at the store, but before that you need to fill up your gas tank. But before that you need to change the oil in the car. But before that you need to help your parent access their email. The next thing you know you're in your living room shaving a Yak asking yourself how you got into this situation. All you wanted to do was get some milk.

You would be better off identifying the core features of your project and concentrating on them, one at a time. What are these core features, what is the value of this feature, and what is the minimum amount that would satisfy that feature. If you're creating a car, you would need a motor to drive the wheels, but a a motor has nothing to do with how to steer a car. You've identified two separate features, one for the motor and one for the steering. I'm not talking about sitting down and writing out full specs and requirements. Just get a basic idea of what are the different parts of what you are building. You'll miss some but that's ok. Find a few features, pick one, and start.

Stay focused on that feature. Hack it together, make it work. But make sure that what you're hacking together is only for that feature. The code you're writing at the time should be responsible for solving that feature, alone. Even if you think that what you're creating can be used for another feature, or that you're repeating something that you made earlier, or you've discovered some new feature that you missed initially (and you will), ignore the impulse to optimize or start adding new features in the middle of your task, you will come back to it later. Just make sure you make notes about those things discovered.

When you're code does what it is supposed to and you've proven it with unit tests (you do have unit test right?), then you can start refactoring. Clean it up, move it around, optimize it, look for areas that a design pattern can fix. Give it a good S.O.L.I.D. overview (if you're working in an OOP language). As long as you have unit tests covering the core responsibilities of your features, you can make changes with confidence.

Once you're satisfied, you can move on to the next feature and repeat. As you complete more features, you can re-address some of the completed code during subsequent refactors. Working like this will ensure that
a) your code works as intended because you've proven it with unit tests
b) your code will be loosely coupled because you were forced to work on a single responsibility at a time.

Refactoring is probably the main take away. But being able to pick specific milestones along the way is important. If you leave it all up to the last minute, it will be easy to get overwhelmed.

So book recommendations:
Martin Fowler's Refactor - https://martinfowler.com/books/refactoring.html
Uncle Bob's Clean Code - https://www.oreilly.com/library/view/clean-code/9780134661742/
Steve McConnell's Code Complete - https://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670

Code Complete.

The fantastic blog Coding Horror (written by one of the founders of StackOverflow) has this to say about it:

> Steve McConnell's Code Complete 2 is the Joy of Cooking for software developers. Reading it means that you enjoy your work, you're serious about what you do, and you want to keep improving. ... Do yourself a favor. Make this the first book you read, and the first book you recommend to your fellow developers.

This book has made balloonanimalfarm a much better programmer. It will save you time by making your designs better at the start of the project, helping you do good defensive programming so bugs come out right away, refactor well when the project becomes too big, choose the right scale of algorithms for your project, and make high quality software.

I recently purchased a predator helios 300 (late 2018 model) for about a grand on Amazon, it has been serving me well for a few months. About 4 ghz & easily upgradable ram/storage, along with a gtx 1060 which will allow you to just about anything, fast. If you don't care about gaming, this is probably the best model to get.

​

Just a hint, gaming laptops now a days can be as fast as custom built PCs due to overclocking & such, but it requires wall power. -no- laptop can have an insanely fast experience without being on charger, none of my laptops will turn on turbo boost unless using wall power. If you don't know what turbo boost is, here is a link to a common/modern/powerful laptop cpu:

​

https://ark.intel.com/content/www/us/en/ark/products/134906/intel-core-i7-8750h-processor-9m-cache-up-to-4-10-ghz.html

​

The "GHZ" advertised is 4.10, which is awesome for -any- computer, but if you look into the specifications list, it normally runs at 2.2 unless 'turbo boost' is enabled, which requires sufficient wall power & proper thermals (just not overheating).

​

It will still be very fast while not on wall power, but you will lose over half of your cpu power (if you OC) when you lose wall power, on just about any laptop with serious power, so just be aware.

​

This is the exact model I purchased:

https://www.amazon.com/Acer-Predator-Overclockable-Aeroblade-PH315-51-78NP/dp/B07CTHLX8C/

​

There is a new 2019 model that was just announced, so you could hold out for that, or get the upgraded 'helios 500' which is the same thing but with more ram (the 300 has 16 gigs) and GPU power.

​

​

Best of luck!

This might help:

https://www.amazon.co.uk/Excel-Power-Programming-Spreadsheet%E2%80%B2s-Bookshelf/dp/1119067723/ref=sr_1_3?ie=UTF8&qid=1527765923&sr=8-3&keywords=excel+vba

But what you really want to do is copy the data into a fresh book so you can play with it, start by looking into pivot tables:

https://www.excel-easy.com/data-analysis/pivot-tables.html

Pivot tables should solve your problem once understand them. If not then move on to more advance formulas and feature combinations. Before finally tackling VBA (actual ms office programming), use VBA only if literally no provided feature(s) can be used to solve your issue.

Also as an accountant, do your career a favor and make sure that you master excel by practicing in your spare time. Mastering excel at home really helped me break into the fin-tech world, now I am a full time full stack developer. Excel can be used to do almost anything with some creativity. Good luck mate! let us know how you do

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.

"The C Language", generally referred to as "K & R" after the authors, is pretty old but still a wonderful book. (C is pretty old too, after all.)

You'll eventually want to supplement it with some newer material but it's such a well-written book that it's great to start with.

Just a few ideas...

• Nerdy stuff from ThinkGeek.
  
• A Raspberry Pi kit, if you think he'd be into tinkering with hardware.
  
• It's probably going to be more than $70, but a nice mechanical keyboard is a great gift. Das Keyboard, Code, and Logitech G710+ are safe choices.
  
• Book-wise, consider Code. It's a classic for every programmer to read.

The requirements side is generally face to face coupled with passing a Word document back in forth. Everybody signs off before we begin.

I use paper and pencil, a white board, and my cat for the actual design work. Long walks, sleeping, discussing with colleagues and cat, and the occasional beer all help. You just have to give it some time to gel in your head and on paper. This can take anywhere from a few hours to several months.

For the really big projects we will walk through all of the business scenarios as a group to verify we have covered everything. If you don't know how something will be dealt with you're not finished.

You might find The Practice of Programming a useful read. Fair warning, it isn't web-centered at all, but still loads of good information.

I'm not much in to design tools, but would use if I was convinced they would help. I've seen them used and generally most of the time spent is goofing with the tool. They also tend to put unnecessary constraints on the solution.

From a quick look it seems that the reviews are sent as a response to the intial GET request on amazon and aren't loaded with AJAX. This should make things relatively straightforward.

The way I would go about this is get the url to the product reviews you want. For FFXV it is:
https://www.amazon.com/Final-Fantasy-XV-PlayStation-4/product-reviews/B00DBF829C/ref=cm_cr_arp_d_paging_btm_2?ie=UTF8&reviewerType=avp_only_reviews&showViewpoints=1&sortBy=helpful


Send a GET request to that page with &pageNumber=4 appeneded to the end. Replace 4 with a counter starting from 1 and counting up until the response no longer returns reviews.

So the final URLS would be:

https://www.amazon.com/Final-Fantasy-XV-PlayStation-4/product-reviews/B00DBF829C/ref=cm_cr_arp_d_paging_btm_2?ie=UTF8&reviewerType=avp_only_reviews&showViewpoints=1&sortBy=helpful&pageNumber=1

https://www.amazon.com/Final-Fantasy-XV-PlayStation-4/product-reviews/B00DBF829C/ref=cm_cr_arp_d_paging_btm_2?ie=UTF8&reviewerType=avp_only_reviews&showViewpoints=1&sortBy=helpful&pageNumber=2

etc.


For each page, after you receive the response, you need to parse the page for reviews somehow. I would recommend using xpath. Using the following snippet "//div[@data-hook='review']" you should be able to pull all the reviews from each page.
If you want to test this out open a review page and open the chrome dev console and type in $x("//div[@data-hook='review']") this should return an array of reviews for the page you run it on.

Next you'll need to move the reviews to the client. I'm not sure how you will be putting them on the website so I can't help you much there. If there is a form or something you can inspect the network packets using chrome dev tools and try to recreate the requests.
If there is a form or something it'll probably be a POST request with some fields. You would then pair the form fields to the corresponding data from amazon and submit the request.

If you are completely unfamiliar with what I've just typed out it'll take quite some time. On the other hand if you write it well it could be reusable in the future and that'd probably look pretty good on you.

These are the things you want to look into:

REST calls

xpath

• Write better code (this is essentially the bible, language independent):
  http://www.amazon.co.uk/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
  
  
• Excellent books to prepare for interviews:
  http://www.amazon.co.uk/Cracking-Coding-Interview-6th-Programming/dp/0984782850/ref=sr_1_1?s=books&ie=UTF8&qid=1452714513&sr=1-1&keywords=cracking+the+coding+interview
  
  http://www.amazon.co.uk/Introduction-Algorithms-T-Cormen/dp/0262533057/ref=pd_sim_14_2?ie=UTF8&dpID=41IHvtO0IxL&dpSrc=sims&preST=_AC_UL160_SR142%2C160_&refRID=1FYKB42A12RXEDF1ZF1V
  
  
• Go get involved with large open source projects on GitHub using the languages you want to be working in.
  
  
• All of these will make you a better programmer. Anyone can look up how to do any of these data structures, the true knowledge is knowing WHEN to use them to proper effect.

What subject exactly? Unicode is kinda complex, but try starting here.

Fundamentals like bits/bytes/numeral systems are annoyingly absent from sites like codecadamy.

Out of modern books, Charles Petzold's «Code» is regarded to be very enlightening.

The book Domain Driven Design: Tackling Complexity in the Heart of Software sort of revolves around this topic. The author speaks at great length about projects where spending way more time in modeling / researching than coding allowed them to solve the problems in ways which allowed them to scale way better - and what they did during that time.

The book is a bit old, but if you take it for the modeling aspect it's still a great read.

Before you look into trying to optimize your code, beyond the basics anyway, I think it's more important to learn how to write readable and maintainable code first. Code that is easier to change, maintain, and write, is much much better than code that runs slightly faster.

Two books that are highly recommended for this are Code Complete and Clean Code.

we love this laptop stand!

https://smile.amazon.com/gp/product/B07CD8LGJ7/ref=ppx_yo_dt_b_asin_title_o09__o00_s00?ie=UTF8&psc=1

and yeah if they decide they dont love programming, it's still a great stand!

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.

Book recommendation:

• Clean Code
  
  Chapter 4 is dedicated to code comments and will help you to understand why some people are talking about self documenting code.
  
  I also recommend you to remember the books author. He also calls himself "Uncle Bob" and you will find several good talks from him on youtube. (Warning: they usually start with some minutes of a completely unrelated topic)
  
  If you take developing software "serious" i would declare reading this book as mandatory. The same goes for his talk about "Expecting Professionalism".

I have a stress ball that's fun to throw at the ceiling. I try to get it as close to the ceiling as possible without touching it. Also, Rubics cubes tend to wear down fast. Get a nice one like this: http://www.amazon.com/dp/B00Q094SIU?psc=1. I have one at my home office and another at my office office. Also, a drinking bird is interesting for a few weeks: http://www.amazon.com/Drinking-Bird-4975-The-Famous/dp/B000JSGLBK

If there is one that is specifically used in your upcoming university course, probably pick that it will give you a head start on the stuff you will be covering.

Algorithms wise CRLS is probably the best book to have.

I would recommend reading Clean Code. It is a good, easy-to-read book about how to write quality code. It can help you a bit for all your languages.

Other than that, perhaps you could helpan open source project? Then you get real coding practice.

The Pragmatic Programmer.

By far, this is the best programming book I have ever read. It discusses programming and software design strategies that are completely language independent, and were rarely discussed in any of my classes.

I wish whoever wrote the legacy code I currently work with had read this book.

The Pragmatic Programmer and Design Patterns.

The Pragmatic Programmer is a really enjoyable read about practical decision making and coding practices. Design Patterns is more for reference, both great books. You can google the design patterns though, but I like to have a copy of the book anyway.

> Can you program regular stuff on there as well?

Yes sir! They're fully functional computers than can run anything from Minecraft to FTP servers.

I recommend a starter kit. They don't cost much more (landing right in your price range) and they have the basic hardware and peripherals to get started.

A couple suggestions:

• https://www.amazon.com/Vilros-Raspberry-Complete-Starter-Black/dp/B00MV6TAJI
  
• https://www.amazon.com/CanaKit-Raspberry-Complete-Starter-Kit/dp/B01C6Q2GSY

If you need to be neo to read code, then that code isn't written well.

Code is read by humans not machine.

So write code like a sentence.

I recommend you to read clean code by Uncle Bob. Something they don't really teach you in school.

Code Complete by Steve McConnell goes over this topic a bit. Great read. https://www.amazon.com/dp/0735619670

I really enjoyed Code.

I feel it's a really accessible summary of what is going on under the hood of a computer.

michael feathers, working effectively with legacy code is the bible.

I quite like the book written by the developers of the language themselves. The C programming language.

Clean Code principles based on Uncle Bob's book.

Links to summaries of the book's principles: Link1 Link2(pdf)

Clean Code

https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882

As stated by u/humpier I would recommend to look at other people's projects on Github and how they do it plus looking at popular frameworks in your preferred language and what their standards are.

As you mentioned Wordpress it seems you're more into web development, so maybe you could start with Laravel or Symfony and try to understand their standards.

And I don't know if this may help you and for me it changed how I think about organizing my code but you could take a look at Clean Code by Robert C. Martin. After reading it some things just fell into place for me, which had a lot to do with naming conventions.

Idk if there is a name for this, but it is a well-known phenomenon, to the extent that it killed companies (Netscape anyone?). The proper way to replace legacy systems is to refactor and evolve them (eg. by splitting out services from a big monolith one by one), not trying to replace them in one big go.

I was told Working Effectively with Legacy Code is a very good on the matter.

https://www.amazon.com/Code-Language-Computer-Hardware-Software/dp/0735611319/ref=nodl_
This book says about everything

you could always buy the bible: http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612/ref=sr_1_5?ie=UTF8&qid=1425602201&sr=8-5&keywords=gang+of+four

otherwise, http://en.wikipedia.org/wiki/Software_design_pattern

The book Code: The Hidden Language of Computer Hardware and Software by Charles Petzold has the answer you are looking for.

The book is a layman-accessible description of how computers work. It starts with a simple description of how data is encoded, to physical encodings of data in the form of electrical currents, to relays, to logic gates, to adders, all the way up to simple op codes in an assembly language, to high-level computer programming languages.

• How computers work
  
• How to program

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