ShouldKnow - Gavin Johnson-Lynn

Authentication vs Authorisation, know the difference

Authentication vs Authorisation is one of the real basics of security, we've all got to start somewhere!

Polymorphism

Dictionary: “The condition of occurring in several different forms” Wikipedia [https://en.wikipedia.org/wiki/Polymorphism_(computer_science)]: “from the Greek roots "poly" (many) and "morphe" (form, shape, structure)” and “the ability in computer programming to present the same programming interface for differing underlying

OOGlossary

Abstraction

Dictionary: “The process of considering something independently of its associations or attributes” Thesaurus: "Detachment, remoteness" Wikipedia [https://en.wikipedia.org/wiki/Abstraction_(software_engineering)]: “It works by establishing a level of complexity on which a person interacts with the system, suppressing the more complex

ShouldKnow

A Brief Look at Encapsulation

Dictionary : “The succinct expression or depiction of the essential features of something” Thesaurus: condense, summarise Wikipedia [https://en.wikipedia.org/wiki/Encapsulation_(computer_programming)] says : “A language mechanism for restricting access to some of the object's components” Encapsulation keeps the internal details of an

ShouldKnow

A glance at HTTP codes and methods

More and more lately I have to speak in HTTP status codes and I'm not fluent. So I thought a round-up of the more common codes would be good. Firstly you need to know that each code is three digits and the first digit

SOLID

Rollup of the SOLID principles

So, the SOLID principles: * S - Single Responsibility Principle [https://gavinjl.ghost.io/s-is-for-single-responsibility-principal/] * O - Open / Closed Principle [https://gavinjl.ghost.io/open-closed-principle/] * L - Liskov Substitution Principle [https://gavinjl.ghost.io/liskov-substitution-principle/] * I - Interface Segregation Principle [https://gavinjl.ghost.io/interface-segregation-principle/

C#

Upturn your dependencies with the Dependency Inversion Principle

I thought this was going to be the simplest principle to explain but after looking at descriptions of it I found the language to be difficult to follow. It took me longer to understand and document than all the other principles put together. The

SOLID

Goodbye monolithic interfaces – the Interface Segregation Principle

“No client should be forced to depend on methods it does not use” (more wikipedia [https://en.wikipedia.org/wiki/Interface_segregation_principle]) This refers to a situation where an interface has more methods than is good for it. If you've got too many

Design

Switch? Swap? Exchange? Substitution! L is for Liskov Substitution Principle

The L in SOLID is the Liskov Substitution Principle. This one is simple, according to Wikipedia [https://en.wikipedia.org/wiki/Liskov_substitution_principle]this means: Let Φ(x) be a property provable about objects x of type T. Then Φ(y) should be

SOLID

Its open but it’s also closed. The Open/ Closed principle!

“A class should be open for Extension but Closed for modification.” This means you should be able to extend the class with additional functionality but the class itself should need no further modifications with the exception of bug fixing. So below we've got an

SOLID

S is for Single Responsibility Principle

I'm currently taking a look at some design basics and starting with the SOLID principles, part one is of course the Single Responsibility Principle. "Each class should have a single reason to change." Let’s explore what ‘reason to change’ actually means. If we've

Subscribe to Gavin Johnson-Lynn