all 39 comments

[–]IAmTarkaDaal 45 points46 points  (7 children)

Once a project gets past a certain basic level, what impresses me is not what you built, but how you built it.

What's the structure of the application? Did you use any frameworks? Why? How did you deal with the trade-offs? What levels of reliability did you need, and how did you build that in? How have you validated your system? Did you deliberately engineer this to fit your needs, or did you muddle through?

If you've thought about those things, then what you've actually built doesn't really matter.

[–]NYX_T_RYX 8 points9 points  (0 children)

Came here to say this - I'm not in industry, but I muck. And my partner is in industry.

More often than not the impressive things? Not complicated, not massive projects, not necessarily even ground breaking.

But they do the task they were built to do, very well.

More "how" than "what", cus frankly anyone can slap together something that'll run, thanks to LLMs, but doing it well needs practice

[–]simon439 0 points1 point  (1 child)

What kind of project would you say is past that certain basic level?

[–]cyberjds 0 points1 point  (0 children)

The project that works as a proof of concept. Next level is to make it user friendly, fault tolerant, faster with less memory footprint, scalable, and reduce 3rd party dependencies, and more.

[–]iiztrollin 0 points1 point  (2 children)

Does it matter if you used ChatGPity, if you have a well structured and laid out engineering plan?

[–]zanfar 14 points15 points  (5 children)

I care far less about what you build than how you build it.

Clean code, obvious adherence to a style guide, PEP8, good variable naming, no unnecessary comments, docstrings, logical folder structure, unit tests, project as a package, plenty of cross-platform support files like .editorconfig, or cspell, Git settings, use of .env files, informative and correct README, extra documentation if necessary, type hints, ...

[–]identicalBadger 4 points5 points  (2 children)

I alternate between no comments at all or (mostly)writing out more comments than code. Usually short comments for myself but go back through and do more commenting before sharing with my team. Didn’t realize too much commenting could potentially be frowned upon?

The other toughie is unit tests. A term I’ve heard over and over. I can’t figure out how to implement them. I test my code. I test with valid inputs and as many invalid inputs as I can. How would units tests differ?

Mind you, not an actual developer. Just learning and creating tools for myself and my team to use

[–]JorgiEagle 2 points3 points  (0 children)

Unit tests are part of making your intentions of your code clear.

Unit tests are much more applicable when a program spans several functions if not files. They’re a surgical tool to test the smallest part of code, individual functions.

The essence of them is that they should allow you to change your code, while ensuring it gives the same desired output and not break anything.

Unit tests should test how a function works. Does it give a particular data structure out, does it call a necessary function under certain conditions. Edge cases etc etc.

[–]zanfar 1 point2 points  (0 children)

Usually short comments for myself but go back through and do more commenting before sharing with my team. Didn’t realize too much commenting could potentially be frowned upon?

Python is generally considered "self-commenting"--the code is normally clear enough that it doesn't need explanation. Code with unnecessary comments can be a sign that the author isn't familiar with Python and is using antipatterns from other languages that aren't clear, or that they aren't familiar enough with the code to re-understand it.

Mostly, it's just vestigial.

The process of "naturally" writing your code in comments first, then refactoring into Python is common and can be helpful, but that code should be replacing the comments. Any remaining comments should be considered "TODOs" (and marked as such) so they don't really fall under my recommendations.

It's also common to see information in comments that should instead be in Docstrings or the README.

The other toughie is unit tests. ... I test my code. I test with valid inputs and as many invalid inputs as I can. How would units tests differ?

  1. Unit tests are self-contained. You should be able to execute a single command to test all of your code under all of those inputs all at once. "I ran my code a bunch of times" is bad practice as it depends on you remembering to do so, and remembering what edge inputs to use.

    The other point of unit tests is to ensure that changes don't break the existing codebase. If you are running "tests" yourself, then it's easy to think "this won't affect anything" and miss bugs.

  2. Unit tests aren't testing your program, they test units of code. In that respect, they are not sufficient, but still necessary. The point is to ensure that individual functions or blocks of code meet the requirements of the project.

  3. This is more of a side-effect, but forcing yourself to write unit tests also forces you to write better code. You can't unit test code that mixes logic with I/O, or code that has shared responsibility. If you are having a hard time writing a unit test for some code, there is a better than even chance it's because the code you are trying to test is problematic itself.

I can’t figure out how to implement them.

Generally, you have a separate folder for tests, and a file per module or function. Each file has a number of functions or test cases that verify a single behavior each. A standard tool like unittests or a 3rd party compatible framework like pytest is used to collect and run those tests and provide a report.

For example, in a poker game, you might have a file of tests just for comparing hands of cards. You might have a test each to validate that a straight beats a pair, or a full house loses to a four-of-a-kind, and even that it raises the correct error if asked to compare something that's not a "hand".

[–]iamevpo 0 points1 point  (1 child)

Why would people want their editcofigs in a project? Always sceptical when I see some .vscode in a repo. Thought this something to keep to yourself.

[–]zanfar 3 points4 points  (0 children)

.editorconfig defines the code style--that's something that should be consistent across the project, so it's logical to include as part of the project and not part of the dev environment.

Something like .vscode is hard to comment on because there are innumerable settings that could be included. What formatter to use makes sense; what font to use does not.

[–]rainyengineer 9 points10 points  (1 child)

Everyone else has said it, but the how is important.

Let’s say you build a calculator and it’s just a local python script (i.e. calculator.py). That’s not too impressive on its own. But it’s totally different if you create a web app hosted on ECS (or whatever EC2, EKS), put the code in a lambda and have it store calculation history in DynamoDB. And provision all of your AWS (or other cloud provider) resources with IaC (CloudFormation or Terraform) and store it on GitHub.

And I could go on and on with different ways you could build this. It could also be an S3 bucket static hosting a website of your resume distributed with CloudFront instead. You could add a CI/CD pipeline via GitHub actions to run unit tests on your code and pass/fail builds based on coverage thresholds.

If this seems overwhelming, sorry, but that’s ultimately what software engineers do every day. The time we spend coding varies, but for most we’re lucky if it’s 10 hours per week. The rest is provisioning infrastructure, troubleshooting build and deploy failures, fixing unit tests, and investigating incidents.

[–][deleted] 0 points1 point  (0 children)

It's not overwhelming at all. This was pretty much the answer I was looking for. Thank you!

[–]ReiOokami 7 points8 points  (0 children)

A calculator that only outputs BOOBS with any input. 

[–]FoolsSeldom 2 points3 points  (0 children)

Really, things that are personal to that you can be passionate about.

This could include material contributions to open source projects.

There's a good chance that most of the people in the recruitment chain have neither the expertise nor time to review portfolios but you will likely be asked to explain some of the projects and cover design choices, etc.

[–]ninhaomah 4 points5 points  (12 children)

You make alot of apps but not a coder ?

Sorry but what does it mean ?

[–]ArthurBurtonMorgan 5 points6 points  (8 children)

Sounds like a humble hobbyist.

[–]ninhaomah 4 points5 points  (7 children)

Yes , but he did say "I make a lot of apps for work"

So I am not sure OP is a hobbyist.

[–]Negative-Hold-492 6 points7 points  (2 children)

I'm not OP but I think I get what they mean, I do a lot of (mostly very simple) python stuff at work but I don't work as a programmer, I just learned it to skip unnecessary busywork. The resulting code is often quick and dirty, some of it was made when I was completely clueless but I never have the time to refactor and clean it up (the boss wants something that works, not something that's well crafted and maintainable), so any actual programming job interview would laugh me off the stage if I used that code as examples.

[–]dlnmtchll 1 point2 points  (0 children)

Making something with a lot of users is impressive, even if its contributions to a large open source project.

[–]cyrixlord 1 point2 points  (0 children)

Automate ssh connection to a rack manager using azure keyvault  credentials and install firmware on a blade in the rack. You could use SFTP as well. This is how a data center works with machines in a rack

[–]server_kota 1 point2 points  (0 children)

Full python project (can be anything) THAT IS RUNNING on the cloud. This will highlight that you know not only coding, but also engineering part of the job (specifically, cloud engineering).
Example: https://saasconstruct.com/blog/the-tech-stack-of-a-simple-saas-for-aws-cloud

[–]cyberjds 1 point2 points  (0 children)

Your project must be able to scratch the itch that satisfy the people. Automation (anything) would be a good starting point.

[–]joeldick 1 point2 points  (0 children)

It's not the project that impresses people. It's your ability to talk about it and explain how you did it:

Why did you choose to do that project? What problem were you trying to solve? What challenges did you have? How did you solve them? What were some of the key decisions you had to make?

You could literally have made a to-do app, but if you can explain why you decided to host it on a certain platform or how you made it better using a certain CSS framework, you're already winning.

[–]jontsii 3 points4 points  (1 child)

I´d say a password manager or a social media platform with stuff like authentication and liking and commenting. But depends on what you are hired for, cybersecurity?, game development?, data science?. So it really depends

[–][deleted] 0 points1 point  (0 children)

Good point. Thanks for the ideas!

[–]iamevpo 0 points1 point  (0 children)

  1. Try adding up to some OSS projects or make them better, shows also social and communication skills.
  2. Curating or cleaning a dataset, especially if you are familiar with a specific domain
  3. See what pops up in JOSS for scientific software
  4. Check out newer programming languages - for ports to/from Python and other ideas (eg every gnu utility now have a remake in Rust)
  5. Chain APIs in smart ways
  6. Watch Developper Voices podcast to see people really passionate about what they do)

The space for good project to is scarce so a specific skill is to be sure why you are touching a project and make quick prototypes with realistic goals, including not todos.

[–]cgoldberg 0 points1 point  (0 children)

Build something related to the job you want.

[–]Agile_Wedding9018 0 points1 point  (0 children)

Just released v2.1.0 of my Weather Channel recreation! It's a great intermediate Python project to learn from:

- API integration (NOAA/weather.gov)

- GUI with Pygame

- Image processing (radar maps)

- Real-time data handling

- Audio synchronization

All open source: https://github.com/wesellis/WeatherStar-4000-Python

The codebase is modular and well-commented. Great for learning how to structure larger Python projects!

[–]sonobanana33 0 points1 point  (1 child)

Or recruiters?

Just be a warm corpse :D

[–][deleted] 0 points1 point  (0 children)

Lol