veyepar: Scalable code design with slimmer django model and more

Author(s):	Dawa Sherpa
Location	Room CR5
Date	jul Sat 16	Days Raw Files
Start	13:45	First Raw Start	12:59
Duration	00:25:00	Offset	0:45:34
End	14:10	Last Raw End	14:29
Chapters	00:00
Total cuts_time	19 min.

https://2016.pygotham.org/talks/248/scalable-code-design-with-slimmer-django-model-and-more
raw-playlist raw-mp4-playlist encoded-files-playlist mp4 svg png

assets release.pdf Slimmer_models_for_more_scalable_code.json
logs
Admin: episode episode list cut list raw files day marks day marks day image_files

State:

Locked:

clear this to unlock

Locked by:

user/process that locked.

Start:

initially scheduled time from master, adjusted to match reality

Duration:

length in hh:mm:ss

Name:

Video Title (shows in video search results)

Emails:

email(s) of the presenter(s)

Released:

has someone authorised pubication

Normalise:

Channelcopy:

m=mono, 01=copy left to right, 10=right to left, 00=ignore.

Thumbnail:

filename.png

Description:

markdown

When you first start your Django project, adding  functionality to
your model comes really easy, because IT IS really easy to do so.
However, as your application size
grow, the code you end up might not be easy to work on anymore. As
engineers, we should pay attention to scalability not only in terms of
number of requests your server can handle, but also how your
application can grow with more features, and more engineers working on
it.

Code scalability is the ability to grow, modify, adopt your code
without a major refactor, lets say every 6 months with many people
working on it at the same time. While I know that it is really hard to
predict the future needs, and designing for future proof architecture
blindly is a waste of time and effort, I do see the need for some
forethought when you put together a solution. A good balance
between current need and future need can be achieved without
sacrificing a lot of productive time. Common smells that indicate 
you do not have scalable code design are :

* Engineer cannot gain insight into what the code is doing by quickly reading the code  ( bug introduction because of mis-understanding )
* Engineer cannot confidently make change to small area of the code (productivity delay, bug introduction )
* Engineer cannot easily evolve the data structure to support new use cases
* Engineer cannot easily to test, modify isolated business logic

All the the above are usually seen when you have a big Django model file with each model having multiple functionality. I would like to review some basic principles to help us build a scalable software system.

Comment:

production notes