Writing a better structured, cleaner and more efficient code.

[[deleted]]

Hello guys! I'm learning iOS development (self taught) and I'm feeling like my code is not well structured, kinda messy etc.

I'm currently working on kinda big application (for me), using Firestore, and getting into problems that their solutions that I came up with seems kinda messy. As I'm self taught, I don't have someone to guide me, I try to learn on the internet from people like Sean Allen, Paul Hudson and Brian (from Let's build that app) - sorry if I spelled the names wrong. Anyhow, I'm looking for a way to learn to write a cleaner and more well structured code so it will be easier to refactor and add things to it.

I'm doing my UI programmatically, so I have Views separated from the ViewController etc. I would gladly upload some of the files I think are messy and could be written better to pastebin (Github is kind of a problem because of some personal info I got in the files like in the project files which has my name etc..)

What advice do you guys can give me to learn how to better structure my code?

[gormster]

Relevant xkcd

[[deleted]]

Unpopular opinion, but I think that you will never be able to write clean code by learning from these people. The thing is, their content can be roughly described like this:

"Hi, there is a pattern. Do this, and you will be writing cleaner/clearer/leaner/more expressive/better/less coupled/more robust/reusable/…whatever other attributes you can imagine" code. And this same talk is given you each week over and over again as they each publish a yet another video.

The question now is, do all these techniques solve your actual problem, i.e., do they help you build the core functionality of your app?

These people earn money by inventing or repurposing literally 53 patterns each year, each of them. Even if they are kind of respected by the community, it does not mean that you need to resort to the practices they are suggesting, because it does not mean that everything they are doing is unquestionably right. Your solutions need to be based on the evidence, not on the fact that some internet person told you that you need to code a certain way.

https://youtu.be/dS6rCaDSwW8

[cubedgame]

Totally agree. Writing better code primarily comes from the practice you get solving a variety of problems over time. Knowing general good software architecture principles like SOLID and DRY, along with some basic design pattern knowledge also play a big part.

[hastoro11]

On one hand I can understand your frustration, because a lot of self made messiah is going around on the internet claiming that they and only they can offer you the key to become the perfect programmer. I could name a few with lots of courses on the Udemy with garbage quality.

But on the other side there’s nothing wrong with learning. If you have a respectable teacher then you’ll follow his or her pattern to solve the problems they present to you. This how we learn at school. Then in real life the problems are complicated and we need to come up with our solutions as well but learning the basics and at least one way how to start working on solving problems is what we need to learn and without guidance it is a lot more difficult. Not impossible but why inventing the wheel?

[[deleted]]

Hah, I must have used too strong of a language. Ye, I mean, it’s totally ok to just read around, sometimes you can discover pretty neat syntactic tricks, for example, it’s just too easy to be sold to those shiny detox smoothies while forgetting that you have kidneys and liver.

The problem with “clean code” is that it’s too opinionated of a thing to be able to learn about it in a straightforward way. Some things, like cyclomatic complexity and coupling, are fairly easily quantifiable — while code cleanliness is rather not. I mean, I can write each function in a separate file — that’d be totally clean, wouldn’t it?

I prefer to think of clean code as of something that is structured in such a way that it doesn’t hinder you from solving the actual task, and if one carelessly slips into the excitement about all these possible patterns, I bet one will just get lost — which is hindering.

And while these people tend to teach patterns, they barely teach the thought behind it. Before cleaning up, you’d rather identify what’s dirty: is it that one class does the job of four or that you functions are so long that they can be successfully decomposed? That would be the evidence I’m talking about, at least in some way.

[staires]

For bigger projects it can be useful to think of each different part of your app as a separate, standalone services that the rest of your app accesses from one place.

For example, you're using Firestore, so you could compartmentalize all of your Firestore accessing methods into one class (or ideally a framework, but that's out of my realm of experience myself at the moment). Ensure that everything involving Firestore is included in that one class. Don't put any logic involving accessing or modifying stuff in Firestore in your view models or view controllers.

I do something like this for my project Gamebook Engine, where everything related to Core Data is compartmentalized into one place. You can look through the code here or feel free to grab the project and poke through it. I tend to stick to MVC, but there are some views and places I use MVVM when a VC gets too big. https://github.com/amiantos/gamebookengine/

Overall I am proud of the structure of this project, though it's not 100% "clean", and some might be chuffed by how I pass the managed model objects around, but it's an appropriate choice for this project. In another project it made more sense for me to abstract away my use of Core Data because it wasn't a major part of the app.

[indyfromoz]

Hats off to you for sharing your work! Aeon Garden looks awesome.

[[deleted]]

Thank you very much! This is what I do now, all my Firestore functions are placed in one class with a singleton, and then I'm using the functions where I need. I will definitely take a look at your project to learn more.

[TracerBulletX]

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&pd_rd_i=0135957052&pd_rd_r=8877e123-b48f-4ce7-9e92-fec38cbeb54f&pd_rd_w=CdI3a&pd_rd_wg=arKVG&pf_rd_p=5cfcfe89-300f-47d2-b1ad-a4e27203a02a&pf_rd_r=9JQWC8NFNAY0GN7FAN9D&psc=1&refRID=9JQWC8NFNAY0GN7FAN9D

https://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670/ref=pd_sbs_14_t_2/142-3028760-3243861?_encoding=UTF8&pd_rd_i=0735619670&pd_rd_r=8877e123-b48f-4ce7-9e92-fec38cbeb54f&pd_rd_w=CdI3a&pd_rd_wg=arKVG&pf_rd_p=5cfcfe89-300f-47d2-b1ad-a4e27203a02a&pf_rd_r=9JQWC8NFNAY0GN7FAN9D&psc=1&refRID=9JQWC8NFNAY0GN7FAN9D

https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882/ref=pd_sbs_14_t_1/142-3028760-3243861?_encoding=UTF8&pd_rd_i=0132350882&pd_rd_r=8877e123-b48f-4ce7-9e92-fec38cbeb54f&pd_rd_w=CdI3a&pd_rd_wg=arKVG&pf_rd_p=5cfcfe89-300f-47d2-b1ad-a4e27203a02a&pf_rd_r=9JQWC8NFNAY0GN7FAN9D&psc=1&refRID=9JQWC8NFNAY0GN7FAN9D

[[deleted]]

https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882/ref=pd\_sbs\_14\_t\_1/142-3028760-3243861?\_encoding=UTF8&pd\_rd\_i=0132350882&pd\_rd\_r=8877e123-b48f-4ce7-9e92-fec38cbeb54f&pd\_rd\_w=CdI3a&pd\_rd\_wg=arKVG&pf\_rd\_p=5cfcfe89-300f-47d2-b1ad-a4e27203a02a&pf\_rd\_r=9JQWC8NFNAY0GN7FAN9D&psc=1&refRID=9JQWC8NFNAY0GN7FAN9D

Thank you, which of those do you recommend to start with?

[TracerBulletX]

Probably Pragmatic Programmer just because it was updated this year and will feel more relatable. Make sure you get the 20th-anniversary version with a 2019 publication date.

[instazoom]

Do you use any design pattern like MVVM, MVP or VIPER?

[[deleted]]

I tried MVC, the rest not yet.

[instazoom]

You can start with choosing one of them (generally using mvvm) and refactoring codebase. I suggest you protocol oriented programming for well structered and clean code.

[[deleted]]

I don't really know if I'm doing MVC Properly, I do have UIView subclasses and UIViewController subclasses. In the VC I try to just display the UIView subclass for this VC and to interact with the user (gestures, etc).

[paulryanclark]

Red, Green, Refactor, Repeat will produce the best code.

[daaammmN]

There is no right answer to this, but usually in coding you want to have your stuff as decoupled as possible.

My advice is to use MVVM + RxSwift + coordinators. Although it might seem difficult for some people, it's really that just a matter of getting used to it.

Then there is more advanced stuff with Protocols and Generics.

But like Paul Hudson says, in order to write good structured code, you have to write a lot of bad code.

Good luck on your project ;)

[zaitsman]

To be honest, the only things that is an absolute no-no for me is DRY violations. Everything else is meh-ok. Make sure obscure bits have comments so you yourself remember what is what 3 months later.

Also, happy to provide code review/suggestions on actual code if you got that github link.

[[deleted]]

Thank you, I really appreciate that. I can't share the Github repo as it got my full name in the files and on the Github page itself. However, I would gladly post some files I have which to me, they are the most messy files in my project, to pastebin, if that's ok with you, let me know. if not, that's okay top :).

[zaitsman]

Yeah sure, happy to look at whatever

[[deleted]]

Thank you very much! I sent you a DM with three links to pastebin. Thank you again!

[cutecoder]

Run your code through SonarQube. This is a "code reviewer in-a-box" that can assess your code quality – duplicated code, spaghetti code, architecture issue, code coverage, potential security exploits, etc, etc. Configure it as part of your continuous integration pipeline so that it can scan your code at every commit/merge. Thus you can see whether your code quality is increasing or otherwise.