Programmers slang
•
3 likes•3,800 views
In modern programming, developers frequently use and follow some principles to become better and produce quality code. This is a talk to introduce yourself to the acronyms that we have encountered most often while writing our day to day code. We will give examples, discuss what they mean and how to follow things like DRY, KISS, TDD and many more.
Recommended
More Related Content
Similar to Programmers slang
Similar to Programmers slang (20)
Recently uploaded
Recently uploaded (20)
Programmers slang
- 2. BOB CRIBBS Python I Ruby I iOS f bocribbz t bocribbz in bocribbz GitHub bocribbz slide share bocribbz http bocribbz.com
- 3. FLOS /flôs/
- 4. FLOS Free Libre and Open Source This is not something that you will hear too often, but its a good concept to follow. ! The programmers community is huge and a lot of them have tons of things to share, so why not join them?
- 5. API /ə pē ī/
- 6. API Application Programming Interface Defines the way software applications can interact with each other.
- 7. CRUD /krəd/
- 8. CRUD Create Read Update and Delete These are the basic operations for persistent storage. ! It’s implementations are found in database systems and in API actions.
- 10. ORM Object-Relational Mapping A technique for converting data between incompatible type systems in OOP languages. ! Some web frameworks implement their own ORMs for mapping to different database systems using the same structure.
- 11. MVC /em vē sē/
- 12. MVC Model View Controller It refers to a pattern for storing and interacting with information.
- 13. MVC Model: refers to storing the information, usually the database layer. ! View: how the user sees the information (eg HTML). ! Controller: performs various operations to produce the expected output or modify the information.
- 14. MVP /em vē pē/
- 15. MVP Minimum Viable Product Represents a strategy used to release a new product with the least needed functionality in order to produce feedback from clients and enhance it later.
- 16. SaaS /sas/
- 17. SaaS Software as a service / Service Oriented Architecture Represents a software architecture where all components are designed to be services. ! Which means, the web is a client/server architecture.
- 18. SaaS It has 3 demands on the infrastructure: ! Communication: allow customers to interact with service ! Scalability: new services can be created rapidly to handle load spikes ! Dependability: service and communication continuously available 24x7
- 19. TDD /tē dē dē/
- 20. TDD Test-Driven Development Is a programming strategy that consists of short cycles, where tests are written first and the actual implementation comes second. ! It’s especially useful to ensure code quality. ! A frequent strategy used with TDD is Red-Green-Refactor.
- 21. TDD def test_my_profile(self):! response = client.get(‘/myprofile/’)! assert response.code == 302! ! def my_profile(request):! return redirect('/login/')! def test_my_profile(self):! response = client.get(‘/myprofile/’)! assert response.code == 302! def my_profile(request):! if not request.user.is_auth:! return redirect('/login/')! return 'OK'! ! ! ! ! ! ! user = UserFactory(’foo’, ’pass’)! client.login(‘foo’, ‘bar’})! response = client.get(‘/myprofile/’)! assert response.code == 200! def test_my_profile(self):! user = UserFactory(’foo’, ’pass’)! client.login(‘foo’, ‘bar’})! response = client.get(‘/myprofile/’)! assert 'Hello foo' in response ! ! ! ! ! ! ! ! ! ! ! def my_profile(request):! if not request.user.is_auth:! return redirect('/login/')! return 'Hello %s' % request.user
- 22. BDD /bē dē dē/
- 23. BDD Behavior-Driven Development Is a technique introduced to ensure that the software is doing what the client expects, while at the same time maintaining code quality. ! Behaviors had to be defined first and implementation had to follow them, by providing test first and only then writing the actual code.
- 24. BDD As a registered user I can visit my profile page.! def test_my_profile(self):! response = client.get(‘/myprofile/’)! assert response.code == 302! ! user = UserFactory(’foo’, ’pass’)! client.login(‘foo’, ‘bar’})! response = client.get(‘/myprofile/’)! assert 'Hello foo' in response
- 25. FIRST /fərst/
- 26. FIRST Fast Independent Repeatable Self-checking Timely These are properties that a good test has to meet in order to be useful and effective.
- 27. FIRST Fast: it has to run quick ! Independent: a test has to be able to be executed isolated and not rely on other tests. ! Repeatable: a test can be executed anytime and the outcome will still be the same. ! Self-checking: it must automatically detect if it passed ! Timely: refers to test being written before code (TDD)
- 28. FIRST - FAST Fast means fast...
- 29. FIRST - INDEPENDENT def test_my_profile(self):! self.client.post(‘register’, ! {‘user’: ‘foo’, ‘pwd’: ‘bar’})! client.login(‘foo’, ‘bar’})! response = client.get(‘/myprofile/’)! assert 'Hello foo' in response def test_create_user(self):! self.client.post(‘register’, ! {‘user’: ‘foo’, ‘pwd’: ‘bar’})! [...]! ! def test_logged_in(self):! client.login(‘foo’, ‘bar’})! response = client.get(‘/myprofile/’)! assert 'Hello foo' in response! !
- 30. FIRST - REPEATABLE def test_last_login(self):! tdelta = datetime.timedelta(days=1)! today = datetime.today()! ! user = UserFactory(’foo’, ’pass’)! user.last_login = today - tdelta! ! tdelta = datetime.timedelta(days=30)! since = today - tdelta! assert user in User.objects.filter(! last_login > since)! def test_last_login(self):! ! tdelta = datetime.timedelta(days=1)! today = datetime.today()! user = UserFactory(’foo’, ’pass’)! ! ! user.last_login = ‘2013-09-01’! ! since = today - tdelta! assert user in User.objects.filter(! last_login > since)!
- 31. FIRST - SELF CHECKING def test_last_login(self):! tdelta = datetime.timedelta(days=1)! today = datetime.today()! ! ! def test_last_login(self):! tdelta = datetime.timedelta(days=1)! today = datetime.today()! ! user = UserFactory(’foo’, ’pass’)! user.last_login = today - tdelta! ! tdelta = datetime.timedelta(days=30)! since = today - tdelta! assert user in User.objects.filter(! last_login > since)! ! ! user = UserFactory(’foo’, ’pass’)! user.last_login = today - tdelta! ! tdelta = datetime.timedelta(days=30)! since = today - tdelta! users = User.objects.filter(! last_login > since)! if user not in users:! print ‘We have a problem’!
- 32. FIRST - TIMELY (TDD) def test_my_profile(self):! response = client.get(‘/myprofile/’)! assert response.code == 302! ! def my_profile(request):! return redirect('/login/')! def test_my_profile(self):! response = client.get(‘/myprofile/’)! assert response.code == 302! def my_profile(request):! if not request.user.is_auth:! return redirect('/login/')! return 'OK'! ! ! ! ! ! ! user = UserFactory(’foo’, ’pass’)! client.login(‘foo’, ‘bar’})! response = client.get(‘/myprofile/’)! assert response.code == 200! def test_my_profile(self):! user = UserFactory(’foo’, ’pass’)! client.login(‘foo’, ‘bar’})! response = client.get(‘/myprofile/’)! assert 'Hello foo' in response ! ! ! ! ! ! ! ! ! ! ! def my_profile(request):! if not request.user.is_auth:! return redirect('/login/')! return 'Hello %s' % request.user
- 33. CI /sē ī/
- 34. CI Continuous Integration Is a practice of running tests and creating a build automatically.
- 35. CI Principles you have to follow for CI: ! Maintain a code repo Automate the build/deploy Make the build self-testable Keep the build fast Everyone can see the results of the build Automate deployment (Continuous Deployment)
- 36. DRY vs WET /drī/ vs /wet/
- 37. DRY vs WET Don’t Repeat Yourself vs Write Everything Twice Is a principle that refers to reducing repeated blocks of common functionality to a separate sequence that can be called independently. ! It will help you achieve more reusability and automation.
- 38. DRY vs WET def login_required():! if not user.is_authenticated():! return redirect(‘/login’)! ! def get(request):! login_required()! [ … ]! ! def post(request):! login_required()! [ … ]! ! def get(request):! if not user.is_authenticated():! return redirect(‘/login’)! [ … ]! ! def post(request):! if not user.is_authenticated():! return redirect(‘/login’)! [ … ]! !
- 39. KISS /kis/
- 40. KISS Keep it simple, stupid Is a principle that the implementation has to follow the simplest logic instead of a complex one. ! It's probably the most difficult strategy in programming. Most user-friendly interfaces and interactions, are probably also the most over engineered.
- 41. KISS Do not overcomplicate design or code, consider different approach and trade-off and finally choose the simplest one, based on system constraints and business rules. ! It will improve testability, usability and your code would probably be self-documented and much easier to refactor in the future, if required.
- 42. KISS def add_user(uname, pwd):! epwd = md5(pwd)! user = User(uname, epwd)! user.save()! return user! def add_user(uname, pwd):! epwd = md5(pwd)! user = User(uname, epwd)! user.save()! ! ! ! send_email(user, ‘Hello World!’)! send_email(admin, ‘New User!’)! stats = Stats.filter('country')! stats += 1! stats.save()! login(uname, pwd)! redirect(‘/myprofile/’)
- 43. XP /eks pē/
- 44. XP Extreme programming Is a software development methodology which is intended to improve software quality and responsiveness to changing customer requirements. !
- 46. Thank you! What are the acronyms you encountered? What are the principles you follow to deliver better code? ! Questions?