As a small blogging website we are constantly on the lookout for good quality content that promotes circular economy and environmental conservation practices

OKOP Show

This little image classifier is a showcase of how easy it is to create a functional image classifier using just basic python and some easy to use and well-documented libraries. I prepared this script for my Informatics I — Python programming tutorial session in November to show my students what some basic python programming can achieve! All code is available in my as well. github repository Our Goal We want to create a simple python script that recognizes a hand-written number. The input image shall all have a fixed size of 64x64 pixels, the images are RGB coloured. Let’s write a python script that analyzes the image and gives us a prediction what number is written on it. We will take the following steps to achieve this goal First, we draw by hand a set of images that display every possible digit that our script shall recognize. This set of images will serve our script as learning data. Next, we want to write a method that opens and normalizes our image so that only the relevant information is kept. Colour and other distracting noise shall be removed completely. Then, let’s create a Database containing all well-defined learning images. We will compare a new input image to the images in the database to make an estimate which number it displays. Finally, we write the comparing algorithm. We take a new input image, normalize it and compare it to every image in our database which computing the similarity based on pixel values. The image-category with the highest similarity will serve us as an estimate. We want to base our algorithm on training, meaning that we do not hardcode how it shall recognize the digit “1”, but it shall recognize it by himself. We do this by providing him a set of well-defined training images, so images that are already classified, named according to the digit they display. Our algorithm will read the images and the class they belong to, and store it in a database. When a new, unknown image is provided, the algorithm loops through the database and computes the similarity to the well-known images. Let’s break that down into smaller pieces and explain them in detail. Let’s Write some Code! Okay, now that we have an idea what our script shall do, lets translate them into actual python code. The Needed Libraries We’ll use two libraries just for open up the images and represent them in a fast way as 3D Arrays. However, we will NOT use any machine learning library like Tensorflow, Keras or SkLearn. To open Images, we will use the Image class from the PIL (Python Image Library). To perform calculations on the image efficiently, we will use the scientific math library numpy. Finally, to store our image database and open it later on, we will use pickle. While pickle is a standard library, the two others have to be installed using pip. $ pip install numpy $ pip install PIL Let’s import these libraries now. PIL Image numpy np pickle from import import as import The Class Structure We want our image classifier to be a class. This has several advantages, for example, it makes it easy to import it to another project later on, and it gives us a well structured project in OOP style. If you don’t know why to use classes, go and have a look at my other Github repo ! Functional vs OOP Showcase Our class shall have a and a -method, as well as a method to & a image-database, an image, normalize a whole database and an image. constructor str create open normalize classify The shall take a with which we classify the image. The method takes a in which the images are stored, and a that will be created containing representatios of these images. constructor databaseName createDatabase folder name of a database The method takes an that is to normalize. The method takes a , just in case that we implement different normalization function later (then we can pass the one we want to apply on the DB as an argument into the method. normalize image normalizeDatabase normalizationFunction If you are not familiar with this concept, read this article ). here Pretty straight forward. Our empty class schema will look like this: : class ImageClassifier : def __init__ (self, database) pass : def __str__ (self) pass @staticmethod : def createDatabase (imageFolder, databasename) pass : def openDatabase (self) pass @staticmethod : def normalizeBinary (image) pass @staticmethod : def normalizeNot (image) pass : def normalizeDatabase (self, normFunction) pass : def classifyImage (self, img, normFunction) pass Do not worry about the -thing there, we will get to that in a bit. @staticmethod Constructor and str-Method Let’s begin with the easy stuff first. An image classifier always works with one database, so our constructor shall define an empty database and the database name. The string-method return a simple description of the class, so with which database the current classifier is working. self._database = self._databaseName = databaseName self._database == : ( + str(len(self._database)) + + str(len(self._database[ ])) + ) : def __init__ (self, databaseName) None : def __str__ (self) if not None return "ImageRegognizer with database of" " different Classes, each containing " 0 " images." Okay, that was easy. Let’s go on with actually creating such a database. Creating the Database We said that a classifier uses a database to classify images. But the creation of such a database is somehow independent of the classifier itself. Creating a database belongs to the ImageClassifier in general, but not to a particular instance of the class. This is why we used the -attribute: It defines that we can use this method without having an instance of the class. This is visible by the absence of the argument at the first position: the Method does not know to what instance it belongs to. @staticmethod self In fact, it is completely decoupled from ANY instance and just sits in the class itself. But what does that even mean? It expresses that the method underneath does not use any instance-specific fields or methods and can be called freely without an instance. This is super cool because we can then create a new database just by calling , and then use that database for any particular classifier we want. ImageClassifier.createDatabase( * ) Fine, we use a then, but what exactly does do now? Well, what do we want to achieve? We want to save a database to the disk containing all images as arrays. Why arrays? @staticmethod .createDatabase() Because we will manipulate the images later on, which we can only do when we see them as arrays. So we need to open our images, convert them to arrays and save them as a database. Let’s get through that step-by-step. The Images-Schema The user will provide us with the folder-name in which the images are located. We as developer define how he has to name the images so that we can identify their class. He has to follow the following structure: -imageFolder — — digit_index.jpg Meaning in the imageFolder, all images are located and named by the digit they display and some incrementing index. You find an example of an image folder in the github repo, but I also give a quick example here: -images — -0_0.jpg — -0_1.jpg — -0_2.jpg … — -0_15jpg — -1_2.jpg … — -9_15.jpg To initially train your classifier, you will need to create such images by yourself. Pay attention to always draw the digit a little different so that our classifier can classify badly drawn digits as well. Fine, can we please code now?? Sure, let’s get into it. The Actual Code We want to keep it simple here and store the images a dictionary where the keys are the digits and the values are lists containing the array-representation of all according images. number_db = {} i range( ):
        number_db[i] = [] for in 10 Now let’s loop through our image folder and open the images by their well-defined name: we assume here that the user always provides 16 images of a kind, so 16 images displaying a zero, 16 displaying a 1 and so forth. We open the image by this naming convention, convert it to an array and insert it into the according list into the dict database: number range(len(number_db.keys())): index range( ):
            image = Image.open(imageFolder + + str(number) + + str(index) + )
            number_db[number].append(np.array(image).tolist()) for in for in 16 "/" "_" ".jpg" By calling , we convert our PIL Image object into a python list. The list represents the image, each sublist of the list represents one row, and each sublist of THAT list represents a pixel, while each pixel consists of three values; R(ed), G(reen), B(lue). The following image should make clear how the list conversion looks like. np.array(image).tolist() Now that we have a dict that serves us as a database, let’s save that dict to the disk using pickle. This is a no-brainer. open(databaseName + , ) db:
    pickle.dump(number_db,db) with ".pkl" "wb" as In the main function of our script, we can now call this method and create a new database pickle. __name__ == :
    ImageClassifier.createDatabase( , ) if "__main__" "images" "number_db" This creates a new in our main directory. number_db.pkl Open Database Okay, now that we have created our database, we need a way to tell our classifier to use it. For that manner, we create an openDatabase method. Why don’t we have to specify the database name? Remember that, when we create a new Classifier, we need to specify what database to use, so the name of the database is already an instance variable of the class-instance itself. open(self._databaseName+ , ) db:
        self._database = pickle.load(db) : def openDatabase (self) with ".pkl" "rb" as The code is simple: Open the database and load the database content out of the pickle into the variable. self._database Normalize Image We have talked about normalization a little bit, but not in detail. Why should we need to normalize an image, and what does that even mean? Well, the only thing that we defined about the input image is that is has to have a fixed size of 64 by 64 pixels. But that still leaves open quite some room for variation: what about the colour of the digit and the background? Can we compare a blue nine on a green background? What about a scanned image, where the image has low contrast and a grey background? This seems hard to handle, but in fact it is easy to reduce these variables. Let’s have a look how an input image may look like. While it looks similar to the digit 8 from our test images (in fact, it is the same image with some visual styling), it is clear that we can not directly compare this image to our database and hope to get a proper result. It would be much nicer if every image had a similar form. Let’s look at a selection of this image and see how we could achieve this reduction. We take a close shot of the region marked in red (have a close look, it is just one pixel column and barely visible) This is the same region, but now zoomed in. We can see some of the pixel values, the leftmost yellowish pixel has the RGB value [244, 240, 125], the rightmost pixel has the RGB value [63, 74, 157]. Remember that the yellowish part does not belong to the digit, while the blue part to the right does. Now we would like to modify that pixel array to be able to clearly distinguish what part does belong to the digit, and what part does NOT. As a first step, we get rid of the colours, because we are actually not at all interested in the these. Why not? Because we can assume that the digit is written on something paper-like, so the digit will have a darker colour than the background, no matter what colour this happens to be. We just want to look at the contrast. So let’s convert this image to Greyscale values only by averaging each pixel: [244, 240, 125] becomes 244 + 240 + 125 = 206, therefore [206, 206, 206]. Now let’s go one step further and make every pixel that is dark fully black, and every pixel that is bright fully white. We make a clear cut: Every pixel that is brighter than 255/2 (255 is the brightest value a pixel can have, 0 the darkest) as bright, every pixel that is darker than 255/2 as dark. We get the following result: We are almost done! See that pixel values? They are always either fully white [255, 255, 255] or fully black [0, 0, 0]. So we store redundant information. Let’s replace [255, 255, 255] with 1 and [0, 0, 0] with 0. We now successfully converted not just a coloured image to greyscale, but a greyscale image to binary. Code Please! Now! Okay, let’s realize that in python. First, we loop through every column of the image. Then, we loop through all the pixels in the column. Then, we loop again through every pixel value and sum up their colour values. If the total colour value divided by three happens to be greater than 255/2, we assign the pixel a 1, otherwise a 0. Finally, we return the image. column image: pixel range(len(column)):
            total_color = color column[pixel]:
                total_color += color total_color/ < / :
                column[pixel] = :
                column[pixel] = image @staticmethod : def normalizeBinary (image) for in for in 0 for in if 3 255 2 0 else 1 return Normalize the Whole Database Now that we can normalize an image, we can also normalize a database by just looping through it every image it contains and replacing the images with their normalized ones. number range(len(self._database.keys())): image self._database[number]:
    image = normFunction(image) : def normalizeDatabase (self, normFunction) for in for in The Classifier Itself Now that so much pre-processing work is done, the classifier itself is pretty straight forward. What we want to do is to open the image, convert it to a numpy array, normalize it with the same normalization function as the database, and then compare it to all the images in the database while keeping track of the similarity between each of them. Let’s start with opening and converting the images: test_image = Image.open(img)
    test_image = np.array(test_image).tolist()
    test_image = normFunction(test_image) : def classifyImage (self, img, normFunction) Now the comparing part starts. First, we initialize a dict in which we will store the similarity between the provided image and each image-class in the database. Then, we loop through the database and compare the two images, pixel for pixel. If the two pixels match, we add two confidence-point to our confidence dictionary for the class which we are comparing to. When the pixels do not match, we substract one confidence point of the compared class. So our confidence dict looks like this: It essentially tells us, how many pixels matched in comparison to all the images in that class. Let’s assume the input image displayed the digit “8”. confidence_dict = {“0”: 55, “1”:4, “2”:32, “3”:120 … , “8”:432, “9”:43} When comparing it to all the images in the database that display a “0”, we may get like 55 confidence points. That seems like a lot, but the absolute value of the number does not matter, because when we compare the input image to the database images displaying the digit “8” as well, we will (hopefully) get a much higher confidence number, like 432! i range( ):
        confidence_dict[i] = number range(len(self._database.keys())): image self._database[number]: column range(len(image)): pixel range(len(image[column])): image[column][pixel] == test_image[column][pixel] == :
                        confidence_dict[number] += image[column][pixel] == test_image[column][pixel] == : confidence_dict[number] -= for in 10 0 for in for in for in for in if 1 2 if 0 continue 1 Wait wait wait. Why do we add 2 confidence points for a matching pixel, but only subtract 1 for a mismatch? Good question! Well, assume you deal with the digit “1” as an input image, and compare it to another “1” in the database. Let’s assume the pictures match nearly perfectly, except one pixel is moved a little bit. See how that generates 2 negative confidence points? So when a pixel does not match, it is treated far worse than when they match. To balance that out we add not just one, but two confidence points for every match. Now we need a little bit of statistics to get a percentage value back from our confidence array. First, we sort the confidences to find out what our prediction is: the digit with the highest confidence number. But we are not done yet: We also want to indicate how sure we are with our prediction: If we predict the image to be a “1”, but we are only 51% sure and it could also be a “7”, our prediction is not worth much. To be fair, we should at last show how certain we are. We do that by comparing the certainty of our prediction with the certainty of our second-best guess: When the second guess is nearly as good as our prediction, we are like 50% certain. But if our guess is prediction has a 3 times higher confidence than our second guess, we can be close to 100% sure to really deal with the number we predicted. We divide 1 by our best guess and multiply the outcome with our second best guess, *100 to get a percentage value. Rounded to two digits, we get a nice and clean percentage value back. max_confidence = sorted(confidence_dict.values(), reverse= ) key, value confidence_dict.items(): value == max_confidence[ ]: key, min(round((( /max_confidence[ ])*max_confidence[ ])* , ), ) True for in if 0 return 1.0 0 1 100 2 100.00 Testing our Script Wow, we are finally done! Let’s test how good our script performs. Write a main function that is executed when our script is directly called and test the script with some test-images (be sure to not include these in the training images, that would be cheating). I have added some test images named test_ .jpg into the main directory, each displaying a digit between 0 and 9. Let’s try it out: Create a new database with our training images, create a new classifier with that database and open the database. digit Normalize the database with our function, then loop thorugh each of the test images and call with the same normalization Function. normalizeBinary .classifyImage() __name__ == :
    ImageClassifier.createDatabase( , )
    imageClassifier = ImageClassifier( )
    imageClassifier.openDatabase()
    print(imageClassifier)
    imageClassifier.normalizeDatabase(ImageClassifier.normalizeBinary) number range( ):
        print(imageClassifier.classifyImage( + str(number) + , ImageClassifier.normalizeBinary)) #Use for testing ImageRecognizer Class if "__main__" "images" "number_db" "number_db" for in 10 "test" ".jpg" The results are pretty good! But wait! What if we do not want to normalize the images, but compare the raw-ones? We have to provide a normalization function, it’s mandatory in some of the function calls! True, we have to find a way around that. But that’s easy, let’s just cheat a little bit and create a normalization function that does — nothing. Just return the blank image again. image @staticmethod : def normalizeNot (image) return Ways to Improve This little script is just the basic of image classifying, right. We could get a lot more out of this algorithm with some tweaks. For example, our algorithm fails right away when it compares a “1” that is in the left half of the image to a “1” that is on the right part, because it can not find any matching pixels. We could solve that by cutting all white space on top and on the left of the digit. Further, our images have to be fixed size, so we could try to make that a bit more flexible by scaling them first. Or we could make the algorithm more efficient by not saving all our images to the database, but sum them up to one, “total-averaged” image of the digit, which would save us a lot of time on bigger training sets. But these improvements are up to you!

[Tutorial] Recognize Handwritten Numbers in Python without any ML-Library

This is intended to create a simple app which drives a “common issue in OOP paradigm” which is code duplication and hidden patterns usually found in real world that can be solved using Inversion of Control techniques and allowing us to perform . tutorial Angular declarative programming Resources (what this article is about): https://github.com/k1r0s/angular2-srp-showcase/tree/master https://github.com/k1r0s/angular2-srp-showcase/tree/normal-oop The App The app should load a list of (authors) in its home page. users If a list element is clicked a dialog should be presented That dialog should have a brief[1] about the selected user and two buttons One button should close the dialog Other button should load user specific ‘post page’ Clicking on an user from ‘South Elvis’ will trigger a random exception Exception should be cached, an error dialog[2] should be presented Post page should render selected user’s specific posts [1] User dialog format/content isn’t part of tutorial’s scope [2] Error dialog format/content isn’t part of tutorial’s scope Rules Each time we perform an ajax request we must show a loading dialog All ajax request should be stored for cache purposes Technical details Users (writers) resource is placed here: https://jsonplaceholder.typicode.com/ users Posts resource is placed here: https://jsonplaceholder.typicode.com/ posts Let’s start You can follow these instructions, step by step. Prepare your workspace $ git clone https://github.com/k1r0s/angular2-srp-showcase.git $ git checkout normal-oop $ npm install Run the code $ npm start browse localhost:4200 Read the code Okay so lets start by opening . This component has the following responsibilities: src/app/components/writers/writers.component.ts Invoke a service to fetch users Render users list Listen clicks on users list Invoke a service to store users request result and the selected user to be loaded on ‘posts screen’ Invoke a service to build a dialog to render selected user Handle an exception if selected user is from ‘South Elvis’ Now lets look over . This one has the following responsibilities: src/app/components/user-posts/user-posts.component.ts Grab selected user from cache Invoke a service to fetch user’s specific posts Render a post list Invoke a service to store posts request result for that specific user Common OOP drives repetition: Let’s see the code at https://github.com/k1r0s/angular2-srp-showcase/blob/normal-oop/src/app/components/writers/writers.component.ts#L41 Most of times a method body that should describe a business action is entangled with code that does not describe at all that action. Like opening a dialog, capturing exceptions, subscribe to close events, etc. In OOP we try to separate concerns by declaring entities (classes) that group actions (methods) that describe . Methods describe what business wants to happen and where (domain speaking) how things should be fulfited. A common issue in OOP paradigm is that, to replicate a behavior, code must be replicated too. Sometimes class extension isn’t enough because your behavior doesn’t always occur in the same spot or you simply don’t have enough time to change whole app arquitecture. For example, a log service has to be invoked at the end of some method calls printing method’s arguments and result but that implementation isn’t important at all in terms of domain problem . Can you deal with logs calls with class extension? nope. meaning that code is polluting your app What about projects with 12 developers coding That’s hidden patterns. For example when a developer is used to add a feature similar or identical a previous one most of them will seek that previous implementation on the code base to look ‘how to deal with the same problem’ or simply paste that code in their feature changing some variables related with the context of that specific screen or feature, while some developers will implement their own code to solve the same problem. We don’t care about which implementation is the best. Different implementations for the same problem drives bugs, code is harder to mantain, etc. An easy solution to deal with this are that all developers must agree. But still duplication spreads. the same behavior with different implementation? interface definition Authentication, Ajax resolution, UX action invocation, exception handling… almost anything that isn’t related with business logic its likely to be invoked in several places and that implementations can pollute your domain logic. Examples Lets back to writers component What is really doing at ? writers.component.ts setup Reading the code we may conclude that: Is reading from cache if resource was already fulfilled (if so list is assigned) and all steps below are skipped If that cache is empty: We must show a loading dialog[2] and we fetch users resource Then we should store that resource on cache by calling a service Then we should hide loading dialog Then we should asign the list to be rendered by the component Many concerns take place as this code gets executed. In terms of domain this is simply . There are a few domain rules that apply on this, … fetch and render users list catch resources, show a loading dialog while requesting a resource That behavior also gets replicated on . But on this case there is a domain concern before: . user-posts.component.ts grab the selected user from cache There is a way to code that implementation abstracting us from component’s specific domain? Yes! We already defined some interfaces that and share: . We also assure that there are no writers.component.ts user-posts.component.ts LoadingDialog, ResourceContainer<T>, LoadingDialog, CacheContainer hidden patterns. Both components have to fetch some resource when created Both components have to show a loading dialog at anytime Both have to write/read from cache something Hence we can achieve this on both components: Note that the same behavior needs to be invoked in different spots and with different context/arguments. writers.component.ts (code) user-posts.component.ts (code) And this works, trust me . (running example) Tip > argsDriverIndex param for @ArgsCacheReader its just a specification of which method arguments index will be used as a serialized key to read/write from cache. This means that user-posts.component.ts will access cache having first fetchPosts argument. Therefore it will not call the same resource twice. Is important to know that these decorators can be imported everywhere and are completly standalone (that depends on you). Meaning that you can remove some of them without messing callstack . while in common OOP implementations you face side effects Conclusion Method and class Decorators are a powerful tool against repetition and, it also provides a needed abstraction layer needed in modern applications. We have cleared infrastructure code from our component by using declarative programing whichs aims for: how “Remove side effects by describing what the program must accomplish in terms of the problem domain , rather than describe to accomplish it as a sequence of the programming language primitives ”. Our code is clear as water and easy to mantain. We have to understand that which can become very different in the near future. So if our abstraction is somehow deprecated, we must remove this decorator from that component which no longer match a pattern (interface), paste its implementation and code the difference. we have created a strong association with two components Bonus Why Decorators? Decorators are bread and butter in modern libraries like Angular, , also in backend, for instance provides a lot of built in decorators to enhace your dev experience, improve readability, separate concerns.. etc. Vue (addon) Nest framework Decorators are nice because provide you a language feature that allows you to add/remove/manage rich implementations without messing in language primitives. Maybe in the near future decorators will be used as “standalone plugins” which can be downloaded and plugged in your code providing features ( ). example For instance, Angular’s decorator is a neat way to register your class as a web component into angular boilerplate. So why you wont define some for your own needs? @Component How to @ in Typescript/Babel? Babel does not support interfaces to deal with hidden patterns , but it supports method and class decorators . Currently you need to deal with which is well explained in . if you need to write a function that needs to be called before specific constructor in some classes ES7 decorators API TS docs I created a that makes very easy define your own method/class decorators. It will allow you to . Of course this tutorial example was made using that library. library change, extend, modify the behavior of methods and constructors non-invasively Give a try!

Angular Tutorial: Separation of Concerns using ES7 Decorators

(OOP) is something that you have to learn by doing. You can read all you want about how a Car can be a subclass of a Vehicle, and buzzwords like “ ”, but until you rewire your brain to think in a different way you won’t fully understand it. Object Oriented Programming polymorphism In this post, I’ll walk you through a real problem, strip out the jargon, and show you how you can understand OOP by changing the way you think about your program. Content Overview Prerequisites Problem Scenario What NOT to do What you SHOULD do Conclusion Prerequisites This isn’t for complete newcomers to OOP, although you may still find it useful. . Perhaps you’ve never really got OOP, and you struggle to design object-oriented programs yourself You should have a working knowledge of OOP - for example, what a constructor is, and the meaning of and . basic public private Problem Scenario We’ll work through a coding test I once had to do for a job application. You are given a text file that represents a maze: XXXXXXXXXXXXXXX
X             X
X XXXXXXXXXXX X
X XS        X X
X XXXXXXXXX X X
X XXXXXXXXX X X
X XXXX      X X
X XXXX XXXX X X
X XXXX XXXX X X
X X    XXXXXX X
X X XXXXXXXXX X
X X XXXXXXXXX X
X X         X X
X XXXXXXXXX   X
XEXXXXXXXXXXXXX `X` represents a wall, `S` is the ‘start’, and `E` is the ‘end’. Spaces are where your ‘explorer’ can travel through the maze. The task is to write a program that fulfills the following criteria: Given a maze, the explorer should be able to drop into the Start location (facing north) An explorer in a maze must be able to move forward, turn left, and turn right An explorer must be able to declare what is in front of them An explorer must be able to declare all ‘movement options’ given their location An explorer must be able to declare how many steps they have taken so far An explorer must be able to report a record of where they have been in an understandable fashion What NOT to do In my early career I would have made the following mistakes when thinking about this problem: I would have thought of my program as a sequence of instructions for the computer to carry out I would have thought about how I would model the data in the computer’s memory I would have imagined a user running the program and interacting with it These are a bit abstract, so let me explain them. I would have thought of my program as a sequence of instructions for the computer to carry out I first learned to program in C, and so my mental model of programming was writing a sequence of step-by-step instructions for the computer to execute. You may have started learning with Python or JavaScript, in which case your mental model will be the same. Unless the very first language you ever used was or C#, you would have thought of your programs as a sequence of instructions. Data comes into the program, each line in the program performs operations on that data, and an output is produced. This is called . Java imperative programming I would probably have thought . And I would have written code - in a main function - that read the file. “What is the very first thing that the program needs to do?…..it needs to read the text file” I’ll use Java as an example, but all this applies to any language, and there’s nothing specific to Java here. public class Main {
    public static void main(String[] args) {
        String maze = new String(Files.readAllBytes(Paths.get("maze.txt")));
} I would have thought about how I would model the data in the computer’s memory Then I would have considered the data, and how it would be stored. I’d perhaps store the data in a 2D array, which makes sense given the maze is a 2D grid of characters. public class Main {
    public static void main(String[] args) {
        List<String> lines = Files.readAllLines(Paths.get(filePath));
        char[][] maze = new char[lines.size()][];
        for (int i = 0; i < lines.size(); i++) {
            maze[i] = lines.get(i).toCharArray();
        }
} I would have imagined a user running the program and interacting with it I would have looked at the specification and considered how the user would interact with the program. So the first one: ). I probably would have done something like this: Given a maze, the explorer should be able to drop into the Start location (facing north public class Main {
    public static void main(String[] args) {
        List<String> lines = Files.readAllLines(Paths.get(filePath));
        char[][] maze = new char[lines.size()][];
        for (int i = 0; i < lines.size(); i++) {
            maze[i] = lines.get(i).toCharArray();
        }

        int[] startCoordinates = getStartCoordinates(maze);
        int[] explorerCoordinates = startCoordinates;
        char explorerDirection = 'N';
    }

    private int[] getStartCoordinates(char[][] maze) {
        // search grid and return coordinates of 'S' [x, y]
} Then maybe I would have given the user a way to interact with the program: public class Main {
    public static void main(String[] args) {

        ...

        int[] startCoordinates = getStartCoordinates(maze);
        int[] explorerCoordinates = startCoordinates;
        char explorerDirection = 'N';

        String userInput = getUserInput();
        
        if (userInput.equals("turn left") {
            explorerDirection = 'W';
            ...
    }

    ...
} ..and so on. At some point, I’d have to have some kind of input loop and kept the state maintained according to the user input, but you get the idea. The point is: I would have primarily had in my mind the idea that this is an actual program that could be used by a real user. I would have modeled the data at a low level. I would have tackled the problem step by step, from when the program is first run.# Perhaps you’re now thinking: but programs made for real users, you think of how data is represented in memory and a program a sequence of instructions! are should is If you’re thinking this then and you you are of course correct there is hope for you yet. You would be amazed at how many people don’t think of programs this way. As a reminder: : Thinking of programs like this will prevent you from properly understanding OOP. You need to rewire your brain and think about your programs a little differently, if only temporarily. But our job for today is to understand OOP and not get fired. What you SHOULD do The first thing is to move away from the computer and get a pen and some paper. What are the ‘things’ in this problem? Write them down. Maze Explorer Great. These are our ‘objects’. class Maze {

}

class Explorer {

} Now let’s consider the two things that objects have: and . state methods State What ‘state’ can a maze be in? It’s the state defined by the text file. It could be this: XXXXXXXXXXXXXXX
X             X
X XXXXXXXXXXX X
X XS        X X
X XXXXXXXXX X X
X XXXXXXXXX X X
X XXXX      X X
X XXXX XXXX X X
X XXXX XXXX X X
X X    XXXXXX X
X X XXXXXXXXX X
X X XXXXXXXXX X
X X         X X
X XXXXXXXXX   X
XEXXXXXXXXXXEXX Or it could be this: XXXXXXXXXXXXXXX
X             X
X XXX     SXX X
X X         X X
X XX   XXXX X X
X XX   XXXX X X
X XXXX      X X
X XXXX XXXX X X
X XXXX XXXX X X
X X    XXXXXX X
X X XXXXXXXXX X
X X XXXXXXXXX X
X X         X X
X XXXXXXXXX   X
XXXXXXXXXXXXXXX So how can we represent that in our `Maze` object? How about a 2D array of characters: class Maze {
    char[][] grid;
} That’s fine: the grid literally is a 2D array of characters. But we can go further and pick out some more objects from our problem. What about the allowed characters in the maze and their meaning? We can define a `MazeElement`, like this: enum MazeElement {
    WALL('X'),
    SPACE(' '),
    START('S'),
    EXIT('E');
} And now our `Maze` is this: class Maze {
    MazeElement[][] grid;
} This has some benefits. For example, instead of writing something like this: if (grid[i][j] == 'X') ..we can instead write this: if (grid[i][j] == MazeElement.WALL) Now we’re working explicitly in the . Instead of the reader perhaps not knowing what `X` was, or having to check for themselves which characters are allowed, now we’re explicitly telling them. problem domain That’s all we need to represent the state of the maze at any time.  Now what about the Explorer? What ‘state’ can the Explorer have? Well, the Explorer has a position in the Maze, which we can represent with grid coordinates. What’s the best ‘type’ to represent that? The primitive example would be to use an array of two integers, but we can do better than that. Most languages will have their own classes to represent coordinates, as it’s such a common problem. In Java, we can use the Point class, from `java.awt`. class Explorer {
    Point currentLocation;
} The Maze itself is also part of the Explorer’s state. Perhaps there are multiple mazes and the Explorer could be in any one of them. class Explorer {
    Maze currentMaze;
    Point currentLocation;
} We know from the problem spec that the Explorer can face in different directions: class Explorer {
    Maze currentMaze;
    Point currentLocation;
    String directionFacing;
} where the direction can be north, south, east or west. But like the MazeElements we can go one better, and define another object: enum Direction {
    NORTH,
    SOUTH,
    EAST,
    WEST;
} then the Explorer becomes: class Explorer {
    Maze currentMaze;
    Point currentLocation;
    Direction directionFacing;
} Again looking at the problem spec the Explorer has a ‘history’: the path they have taken and the number of steps. So we can add: class Explorer {
    Maze currentMaze;
    Point currentLocation;
    Direction directionFacing;
    int stepCount;
    List<Direction> path;
} Actions We’ve defined all our objects, and their state: Maze
    grid
    
Explorer
    currentMaze
    currentLocation
    directionFacing
    stepCount
    path

MazeElement
    WALL, SPACE, START, EXIT

Direction
    NORTH, SOUTH, EAST, WEST As well as state, objects do things. Or more accurately, . things they allow you to do to them So let’s go through the problem spec to see what we need them to let us do. Given a maze the explorer should be able to drop in to the Start location (facing north) class Explorer {
    ...

    void enterMaze(Maze maze) {
        // TODO
    }
} We’re not going to implement the method yet as we’re still designing our objects. Remember to sketch out your objects up front, before you start writing any real code. An explorer in a maze must be able to move forward, turn left or turn right Now we’re seeing how easy this is: class Explorer {
    ...

    void enterMaze(Maze maze) {
        // TODO
    }

    void moveForward() {
        // TODO
    }

    void turnLeft() {
        // TODO
    }
   
    void turnRight() {
        // TODO
    }

} Note that each of these will change the state of the Explorer. will set , and . will increment , add to the and change the . methods enterMaze currentMaze directionFacing currentLocation moveForward stepCount path currentLocation An explorer must be able to declare what is in front of them class Explorer {
    
    ...

    MazeElement declareWhatIsInFront() {
        // TODO
    }    

} An explorer must be able to declare all movement options from their given location We might have questions about what exactly this means, but it doesn’t matter for now. class Explorer {
    
    ...

    Set<Direction> declareMovementOptions() {
        // TODO
    }    

} An explorer must be able to declare the number of times they have moved forward so far class Explorer {
    
    ...

    int declareNumberOfSteps() {
        // TODO
    }    

} An explorer must be able to report a record of where they have been in an understandable fashion class Explorer {
    
    ...

    List<Direction> declarePath() {
        // TODO
    }    

} Notice our method names have “declare” in them a lot. This matches the language of the spec, but actually it’s a little unclear what “declare” means. Does it mean “return” or could it mean “print”? To make things clearer we can change “declare” to “get”, so our object now looks like this: class Explorer {
    Maze currentMaze;
    Point currentLocation;
    Direction directionFacing;
    int stepCount;
    List<Direction> path;

    void enterMaze(Maze maze) {}
    void moveForward() {}
    void turnLeft() {}
    void turnRight() {}
    MazeElement getMazeElementInFront() {}
    Set<Direction> getMovementOptions() {}
    int getNumberOfSteps() {}
    List<Direction> getPath() {}
} Public vs Private Looking at the Explorer object above, we only need to “expose” the to the user (the user of the class) to fulfil the spec. We don’t need the user to be able to access the state - they do that through the methods. methods class Explorer {
    private Maze currentMaze;
    private Point currentLocation;
    private Direction directionFacing;
    private int stepCount;
    private List<Direction> path;

    public void enterMaze(Maze maze) {}
    public void moveForward() {}
    public void turnLeft() {}
    public void turnRight() {}
    public MazeElement getMazeElementInFront() {}
    public Set<Direction> getMovementOptions() {}
    public int getNumberOfSteps() {}
    public List<Direction> getPath() {}
} In general, state is always private, and methods are usually public. The public methods define the : how a user of the object interacts with it. interface Let’s say though that when writing the public methods we find we’ve got repeated code in a few of them, and we want to extract that into a different method. Let’s say the new method is this: Point getPointInDirectionOf(Direction d) {} which returns the in a given direction. This could be used by the method, and . Point moveForward declareWhatsInFront declareMovementOptions This method should be private. It’s only used internally, by the object itself. The ‘user’ of the class doesn’t need to access that method. They don’t even need to know that it exists, because it doesn’t affect the behaviour of the class at all. This is called encapsulation. The ‘inner workings’ of the object are not exposed to the ‘user’ of the object. class Explorer {
    private Maze currentMaze;
    private Point currentLocation;
    private Direction directionFacing;
    private int stepCount;
    private List<Direction> path;

    public void enterMaze(Maze maze) {}
    public void moveForward() {}
    public void turnLeft() {}
    public void turnRight() {}
    public MazeElement getMazeElementInFront() {}
    public Set<Direction> getMovementOptions() {}
    public int getNumberOfSteps() {}
    public List<Direction> getPath() {}

    private Point getPointInDirectionOf(Direction d) {}
} This private method isn’t something you’ll be able to plan up front - you’ll only encounter it when you get to actually implementing the methods. I include it here simply to explain public and private methods. As you begin to write the actual code you’ll also discover things you need the Maze to do, which aren’t necessarily in the problem spec. For example, the Explorer is going to have to ‘ask’ the Maze “ ”. In that case the method on the Maze should be , because that functionality being made available to other objects, in this case to the Explorer. which elements are at coordinate x, y? public is Constructors All classes need a constructor. The function of the constructor is to initialise the object’s state. In the case of the Maze, we need to set the , which we read from a text file. grid public Maze (String fileName) {
    // TODO: iterate though characters in the file and assign them to the grid
} For the Explorer, what state do we need to set? private Maze currentMaze;
private Point currentLocation;
private Direction directionFacing;
private int stepCount;
private List<Direction> path; We already have a separate method which will assign (although you may choose to do that in the constructor instead if you wanted), so the can be initialised to . enterMaze currentMaze currentMaze null The other can be initialised to in the case of the and , for , and an empty list for . fields null Point Direction 0 stepCount path public Explorer() {
    currentMaze = null;
    currentLocation = null;
    directionFacing = null;
    stepCount = 0;
    path = new ArrayList<>();
} Conclusion Our objects look like this: class Maze {
    private MazeElement[][] grid;

    public Maze (String fileName) {}

    public MazeElement getElementAtCoordinate(int x, int y) {}
}

class Explorer {
    private Maze currentMaze;
    private Point currentLocation;
    private Direction directionFacing;
    private int stepCount;
    private List<Direction> path;

    public Explorer() {}

    public void enterMaze(Maze maze) {}
    public void moveForward() {}
    public void turnLeft() {}
    public void turnRight() {}
    public MazeElement getMazeElementInFront() {}
    public Set<Direction> getMovementOptions() {}
    public int getNumberOfSteps() {}
    public List<Direction> getPath() {}
}

enum MazeElement {
    WALL('X'),
    SPACE(' '),
    START('S'),
    EXIT('E');
}

enum Direction {
    NORTH,
    SOUTH,
    EAST,
    WEST;
} Note that we haven’t written any actual code yet - this is all just designing our objects up front. Notice how different that is from our first tactic of seeing the program as a sequence of instructions executed one by one. In fact, there’s almost nothing here that’s language specific. You can apply the principles here to almost any object-oriented language. By thinking about your objects up front you’ve simplified the task massively. Now you can tackle each part of the problem spec in isolation. This relieves you of the burden of having to keep the whole problem in your head at once, which you’d have to do if you were writing imperative code that goes from top to bottom. Note as well that we haven’t considered how a user would run and interact with this problem. When writing OOP you need to think more abstractly, and tackle small pieces of the problem in isolation. If we did want to add a UI on later that would be easy to do in a new object, that interacted with our Maze and Explorer via their interfaces. The problem spec doesn’t ask for that. Also published here. Next In my next post, I’ll use this same Maze example to show you how to use Test Driven Development (TDD) to make your life even easier when implementing the methods.  To make sure you don’t miss it, . follow me on Twitter

To Understand Object Oriented Programming, Think About Programs a Little Differently

Let's learn about via these 38 free stories. They are ordered by most time reading created on HackerNoon. Visit the to find the most read stories about any technology. Oop /Learn Repo 1. Design Pattern: Strategy Pattern in Practice Learn strategy design patterns with practical examples. Why and how to use strategy patterns in software design. 2. OOP in Python: Understanding Private and Public Methods This blog post is part of a series of tutorials on Object-Oriented Programming in Python 3.0. We will try to understand the types of methods and their uses. 3. Inheritance vs Composition in JavaScript Inheritance vs Composition in JavaScript. What is better, when use inheritance, when use composition. We will look at  different examples on JS. 4. Celebrating 50 Years of Smalltalk In 1972, Alan Kay, Dan Ingalls, and Adele Goldberg at Xerox PARC created a revolutionary new programming language called Smalltalk. 5. Learning Duck Typing in Javascript This article dives into learning duck typing in Javascript and examples of polymorphism. 6. Introduction to OOP in Javascript Javascript used to be, just a few years ago, one of the most disliked languages by the community, it's unnatural behavior was a common inspiration for jokes between developers. One of the main complaints was about the lack of a simple syntaxis to work with classes. 7. GRASP Principles - Part 3: Polymorphism, Pure Fabrication, Indirection, Protected Variations The last part of GRASP is where we will learn polymorphism, pure fabrication, indirection, and protected variations and how to use them in our projects. 8. Understand the Intent of Patterns And Principles Before Applying Them TL;DR; 9. Raffaele Florio Writes about the Most Misunderstood Programming Paradigm Raffaele Florio loves to define himself as an abstractions explorer. His main passion is software developing. He's digging a lot in OOP and concurrent models. 10. 3 Simple Rules to Writing Better Code Instantly Learn how you can improve your code quality in an instant following 3 simple rules that we cal 11. SOLID Principles in JavaScript: What Does the "O" Stand For? Hello, guys. This is the second article about SOLID principles with Javascript examples. In my previous article I described what are patterns in general, what is SOLID and why we should use them. If you haven't read it, pls, read it now and continue read current article after the previous one. 12. Implementing an Event Loop in Java for Fun and Profit An event loop waits and reacts to events. In this article a multithreaded Java implementation is presented. A real world scenario inspired its implementation. 13. Once Upon a Time in Javascript: Classes and Inheritance Classes in javascript were first introduced as part of ECMAScript 6 standard back in 2015. Today, they feel like something natural, but how was javascript before them? 14. Java Constructor Interview Questions Here we've listed the most commonly asked concepts on constructors in java that can help you ace your java interview. 15. SOLID Principles in JavaScript: What Does the "D" Stand For? Hello, guys, this is the last part of SOLID Principles in JavaScript and if you haven't read the previous three (first part, second part, third part, fourth part), I highly recommend to read them first and come back here. 16. Does Golang Follow the Object Oriented Programming Paradigm? Many are wondering whether Golang is a language that can apply the Object Oriented Programming paradigm. Let's discuss this here. 17. Building An In-memory Database in Go Building an in-memory database in golang is a basic task that you are likely to have to do. It needs you to make a database and a table before organising. 18. How to Use the Iterator Pattern in C# According to Gang of Four, the iterator pattern provides a process to obtain the aggregator object without knowing its implementation. 19. SOLID Principles in JavaScript: What Does the "L" Stand For? Hello, guys, this is the third part of SOLID Principles in JavaScript and if you haven't read the previous two (first part and second part), I highly recommend to read them first and coming back here. 20. SOLID Principles in JavaScript: What Does the "I" Stand For? Hello, guys, this is the fourth part of SOLID Principles in JavaScript and if you haven't read the previous three (first part, second part and third part), I highly recommend to read them first and come back here. 21. A Practical Guide to Interfaces in Golang A simple and explanatory guide to understanding interfaces in golang. 22. The 3 Stages to Making Your Own No-Code Solution Create your own no-code solution in three easy to follow steps. 23. Getting Started Debugging Spring Transactions in Production We use annotations to denote transactional behavior in modern Spring so we have no code, no failure, no debugging... But is it really? 24. Can You Really Code Without IF Statements? I went to an OOP workshop by Sandi Metz several years ago. She made a comment that at one of her previous jobs, they didn't use if statements. 25. Objects & Pursuit of Happiness: Understanding Object Oriented Programming (OOP) In a good object-oriented system, each object has the right responsibilities. 26. Java: The Object Equality Problem I was writing some Java test code when I faced up the voracity of the equals method. It presents, despite its ostensible simplicity, a tricky problem. 27. Uncover the Alias Pattern The Alias pattern minds two issues. Extending how a final class builds its objects. 28. Interservice Communication in Microservices: 3 Common Misunderstandings Think back to the last time you worked in a distributed system, did you consider using something other than RESTful HTTP calls as the method of communication between components in this system? 29. The Smart Way to Clone Django Instances How to implement proper reusable clone for Django model instances with related objects. 30. Building Your Own Programming Language From Scratch: Part IX - Hybrid Inheritance In this part of creating programming language, we'll implement the hybrid inheritance for the classes like in C++ and write a calculator with multiple classes 31. A Game to Boost Your Java Object Oriented Programming Skills This is a simple black screen console game where first the program will automatically generate a random number, and all the players who play the game here will continue to guess the number one by one and match it with the previous program. The game will end if it matches the program's generated number. Whoever matches will be the winner of this game. Here, we will add another interesting feature which is a counter. What is a counter? It's not just a recorder that will keep recording how many times the player is guessing and how many guesses after which a winner is actually found. 32. Extending Laravel Artisan Commands 33. Understanding JavaScript Prototypes and Its Methods Get deeper understanding what is prototype, Object.setPrototypeOf and obj. and ways of use it in JavaScript. proto 34. Spring Framework: To Use Or Not To Use, That Is The Question It's impossible to write OOP code with Spring. From its core it promotes the use of singletons and anemic data structures a.k.a. data "objects" a.k.a. DTO. This fuels procedural programming and kills OOP. 35. SOLID Principles of Object Oriented Design And Architecture Object oriented programming (or OOP) is a style of programming that encapsulates data and behaviours into models known as objects. In this way, related code is grouped together and kept separate from other code, and provides reusable blocks that can be used to rationalise the problem at hand. 36. SOLID Principles: A Simple and Easy Explanation SOLID Principles is a coding standard that all developers should have a clear concept for developing software in a proper way to avoid a bad design. It was promoted by Robert C Martin and is used across the object-oriented design spectrum. When applied properly it makes your code more extendable, logical and easier to read. 37. Overloading Vs. Overriding in C# Method overloading and overriding are two common forms of polymorphism ( the ability for a method or class to have multiple forms) in C# that are often confused because of their similar sounding names. In this article, we show the difference between the two with some practical code examples. 38. Refactoring With Tests in Python: a Practical Example This post contains a step-by-step example of a refactoring session guided by tests. When dealing with untested or legacy code refactoring is dangerous and tests can help us do it the right way, minimizing the amount of bugs we introduce, and possibly completely avoiding them. Thank you for checking out the 38 most read stories about Oop on HackerNoon. to find the most read stories about any technology. Visit the /Learn Repo

38 Stories To Learn About Oop

Understand the different types of methods and how to use them in this Python Class A is a function embedded inside a . method class must have at least one parameter. There is no such thing as a parameterless . Typically is used as a parameter in that don't need any custom parameters. refers to the for which the is called and makes the and available for the method. Using the word is a norm that is typically followed. So even though can be replaced with any other word, doing so will add unnecessary surprises. A Method method self methods self object method object's variables methods self self Case Let's assume that from our successful delivery of the first simple project on creating a list with the ability to add and remove elements, we have got a new customer. He wants a similar list but with a slightly requirement - he wants to restrict the type of elements only to numeric types. strict Since the basic requirements are still the same: It's a list, It should be able to add and remove elements, And it should show the entire list. We will re-use the class that we created earlier and build on that using a called . Inside we can see two have been defined: , and . More about this is provided later. NumList subclass StrictNumList StrictNumList methods __check_value() add_value() lass NumList:
    def __init__(self, name = ""):
        self.instName = name
        self.__list = [] 
    
    def add_value(self, val):
        self.__list.append(val)
    
    def remove_value(self):
        rv = self.__list[-1]
        del self.__list[-1]
        return rv
    
    def get_list(self):
        return self.__list

class StrictNumList(NumList):
    def __init__(self, name):
        super().__init__(name)
        
    def __check_value(self, val):
        return str(val).isalpha()
            
    def add_value(self, val):
        if not self.__check_value(val):
            super().add_value(val)
        else: 
            input_val = input("Insert a number: ")
            val = float(input_val)
            super().add_value(val) sl01 = StrictNumList(name = "Number List B1")
sl01.instName
sl01.add_value(2)
sl01.add_value("abc") Insert a number: 5 sl01.get_list() [2, 5.0] Constructor - A Special Method or Python is a special kind of that's used to initiate a . __init__ constructor method class It runs every time the is instantiated and makes the usable. class class It must have at least one parameter - to make properties of the available. self object Unlike other methods, can't return a value or can't be invoked inside or outside of a . For example, you can't create call a method like < >< > . __init__ class object name . __init__() 2 Types of Methods Like , can be public or private, or better called private (remember ?). variables methods partially name mangling 1. Private Methods Naming a private follows the same pattern as the private - add two underscores ( ) before the method name. method variables __ Name mangling works with name the same way it works with the . class variables Why Use a Private Method? The same reason for using a private variable. The primary reason for creating these methods is to be used in other methods thus they don't need to be accessible directly from objects. But as we know from the last blog, name mangling actually makes them available. So using the mangled name we can actually access the private methods too. In our example class StrictNumList we have created as a private method. Because its main purpose is to be used inside the method. But check out the below code to see how we can still access this method using the mangled name! __check_value() add_value() # calling private method - __check_value() using its mangled name 
sl01._StrictNumList__check_value('5.5')

False 2. Public Methods Public can be accessed directly from the using dot notation i.e. < >< >< >. In our example, is a public variable. methods object object name . method name add_value() 🛑 But notice how we have defined this method in both the and . This is called . super subclass method overriding Method overriding happens when you define the same method differently in the subclass. To use method overriding successfully you need to meet two conditions: It's only possible in the inheritance context. Or in other words, inheritance doesn't work inside the same . class method class The should have the same name and number of parameters as the . subclass superclass 🛑 Also notice, how the method from the was utilized in the method in . add_value() superclass add_value() subclass SuperNumList What's Next Till now in this series: OOP in Python We introduced and their basic building blocks, classes We learned about and its application of it using , inheritance Subclass We detailed and, in this post, . variables methods In the next post, we will try to get an insider view of the Python . And in doing so, we will see how learning about these topics will come in handy! Happy coding! exceptions

OOP in Python: Understanding Private and Public Methods

Responsibilities are what differentiate objects. They represent what an object can do for us. And in a good object-oriented system, each object should have correct responsibilities. Is there any criterion to help us to verify and find them? I think happiness is a good answer. A metaphor The common way to define objects is wrong. Objects are not just data plus functions. In other words, objects are not a C file containing structs and related functions. They are much more. , the OOP inventor, majored in biology. For this reason, the analogies between - the smallest unit of life - and objects are far from casual. . Objects are inspired by life. Objects are living organisms. And in an object-oriented system, they collaborate to evoke a specific domain. Each object is responsible to do something. Alan Kay cells Objects are inspired by the cells Thanks to this point of view, the definition makes sense: happiness Happiness is a state of well-being that encompasses living a good life, one with a sense of meaning and deep contentment. So an object is happy if it does what it should do in the modeled domain. No more, no less. Objects are in pursuit of happiness. An example The majority of object-oriented systems are tragedies. And common practices, considered good, are actually bad. I refer to , , Service objects, etc… DTO ORM To show the differences I’ll consider a domain model with two points of view. The first one using common practices, the second one using object thinking. The domain regards a pastry shop showcase. Talking with the pastry shop owner we identified five high priority : user stories As an owner, I need to track pastry details, so that I can update my catalog; As an owner, I need to remove tracked pastry details, so that I can update my catalog; As an owner, I need to see tracked pastry details, so that I can manage my catalog; As an owner, I need to sell pastry with a given quantity, so that clients can buy them; As a client, I need to see the pastry showcase, so that I can see what I can buy. Sad objects With common practices in mind we usually start with: interface PastryRepository {
  void save(Pastry pastry);
  void delete(String name);
  List<Pastry> findAll();
}

@Entity
class Pastry {
  @Id
  private String name;
  private Double price;
  private List<String> ingredients;

  // getters, setters ...
}

interface ShowcaseRepository {
  void save(ShowcaseEntry);
  List<ShowcaseEntry> findAll();
}

@Entity
class ShowcaseEntry {
  @Id
  private UUID id;
  private Pastry pastry;
  private Integer quantity;

  // getters, setters ...
}

class PastryService {
  // constructor

  void sell(Pastry pastry, Integer quantity) {
    // sell a pastry
  }

  void save(Pastry pastry) {
    // save a pastry
  }
} According to the previous happiness definition, the objects have suicidal thoughts. They’re central in the conversation with the owner, but here they’re underestimated. They're screaming that they can do more for us. They are reclaiming respect. Pastry Furthermore, we defined , , and . But the pastry shop owner never mentioned them in our conversation. They’re out of place. In other words, they don’t know their place in the Universe (the domain). PastryService PastryRepository ShowcaseEntry ShowcaseRepository It’s a tragedy. Happy objects We can start with: interface Pastry {
  void sell(Integer quantity);
  JsonObject description();
}

interface Details {
  void track();
  JsonObject description();
}

interface Showcase {
  void add(JsonObject description, Integer quantity);
  JsonArray description();
}

interface Catalog {
  void add(JsonObject description);
  void remove(CharSequence name);
  Optional<Details> details(CharSequence name);
  JsonArray description();
} The first difference is that every object concerns the domain. They aren’t out of place. After all, they were born starting from user stories. The second difference is that there isn’t any passive object. In the previous example, was a DTO without responsibilities. It was nothing more than a or a C struct. It was really sad because from the stories it’s clear that it'd like to sell itself. And with the responsibility to describe itself it knows its role in the Universe (the domain). Analogous reasoning applies to the other objects. Pastry Map Conclusion Considering the living organism metaphor, the happiness criterion can help us to identify responsibilities and objects. If an object has too many responsibilities, it will be under pressure. And this means we missed one or more objects. If an object hasn't responsibilities (e.g. DTO), we added bad objects that don't reflect the domain. In conclusion, sad objects don't reflect the modeled domain. The latter should be the only one that drives us while writing object-oriented systems. With this in mind, we can assign correct responsibilities. And ask ourselves: Is this object happy to have this responsibility in this domain? If we forgot this point we’ll write tragedies. And common practices commit this crime. So happy coding and let’s spread happiness!

Objects & Pursuit of Happiness: Understanding Object Oriented Programming (OOP)

Javascript used to be, just a few years ago, one of the most disliked languages by the community, it's unnatural behavior was a common inspiration for jokes between developers. One of the main complaints was about the lack of a simple syntaxis to work with classes. WHY OOP? Most of the popular languages use the OOP philosophy, many companies need employees who can comprehend how to work using classes. Some of the most common questions in interviews for developer positions are related to a basic understanding of how OOP works. The core concepts of object-oriented programming languages (inheritance, encapsulation, polymorphism, abstraction) will be always present in our job as software developers as long as you work with a language that let you declare a class, even if you don't use it frequently, these concepts will be there in the libraries, frameworks, in that project that you have to maintain. The solution with ECMAScript 5 was to use prototypes that simulate the class behavior, but the generated code was long and hard to understand, and maintain. for some other developers, the solution was to work with Typescript or some other superset of javascript. pepe= { : , : , : { + .name+ + .age}}; .log(pepe.age); .log(pepe.getData()); let name "pepe" age 12 getData ( ) function return "name: " this ", age:" this console //12 console //name: pepe, age:12 Thanks to ECMAScript 6, introduced in 2015, we have a modern syntax to create classes. Let's see a simple example of the basic structure: { (name, price, autor){ .name=name; .price=price; .autor=autor; .giveMessage = +(amount* .price);
}
}
book1 = book( , , ); .log(book1.name); .log(book1.giveMessage( )); .log(book1 book); class book constructor this this this this ( )=> amount "total price is:" this new "Harry Potter" 300 "JKR" console // Harry Potter console 5 // total price is: 1500 console instanceof //true If you have work with OOP languages before you will quickly get the basics concepts present here. "First of all, the class definition in the first line, secondly the constructor of the class which receives the initial parameters, third the creation of the variables and methods, and lastly the creation of an instance. With "<instance> instanceof <class>" we can check if <instance> is an instance of the class <class>, then it returns true, otherwise false. In this article I don't want to focus on those basics concepts, instead, I want to talk about the four fundamental concepts in OOP: Inheritance Encapsulation Abstraction Polymorphism Inheritance in Javascript In OOP, inheritance means that you can inherit methods and properties from a different class (or many different classes). Child classes will extend the behavior of its parent class. In the next example, cat class inherit can use the properties and methods from its parent class, animals: { (size, kilograms, name){ .size=size; .kilograms=kilograms; .name=name;
    }
    
    givePounds(){ .kilograms* ;
    }
    } { (size, kilograms, name, race){ (name, kilograms, name); .race=race;
    }
    weightMessage(){ + .kilograms+ + .givePounds()+ ;
    }
    } c = cat( , , , ); .log(c.name); .log(c.weightMessage()); class animals constructor this this this return this 2.2046 class cat extends animals constructor super this return "this cats weights " this " kgs or " super " lbs." let new 10 30 "pepe" "russian" console //pepe console //this cats weights 30 kgs or 66.138 lbs. With "extends" we indicated the parent class, with super we pass the parameters to the parent class when we create an instance of a cat class. Abstraction in Javascript Different to the other concepts, abstraction is still not clearly defined in ECMAScript 6, but there is a way to implement its behavior: { (name) { ( .constructor === AbstractArtist) { ( ); 
        } .name = name
 }
} { (name, last_album) { (name); .last_album = last_album; .log( + .name+ + .last_album);
 }
}


juanes = musician( , ); jose = AbstractArtist( ); .log(jose.name); class AbstractArtist constructor if this throw new TypeError 'Abstract class "AbstractArtist" cannot be instantiated directly.' this class musician extends AbstractArtist constructor super this console "artist: " this ", last album: " this new "juanes" "mi tierra" // artist: juanes, album: mi tierra new "jose" // throw error console This way, the "abstract class" throws an error when it's instantiated, but it works when another class uses it to be extended. Polymorphism in Javascript Polymorphism is the capability to perform a single action in different ways. Other languages like Java and C# are type-safe and the overriding requires some special syntax. But in javascript this is performed more directly, let's see an example: { (size, population){ .size = size; .population = population; .giveDensity = +( .population/ .size)+ ;
        }
    } { (size, population){ (size, population); .giveDensity = +(population* /size)+ ;
        }
    } japan = country( , ) usa = englishCountry( , ) .log(japan.giveDensity()); .log(usa.giveDensity()); class country constructor this this this => () "this country has " this this " citizens for each square kilometer" class englishCountry extends country constructor super this => () "this country has " 0.621371 " citizens for each square mile" let new 377975 126150000 let new 9833520 328239523 console console Class "englishCountry" overrides the default behavior of the method "giveDensity" of its parent class "country". Encapsulation in Javascript Giving free access to parameters of a class can be inconvenient sometimes... Once in a while, we will need to keep safe some attributes or methods. To do this we could declare them as private, in this way the users can not directly access those attributes and methods. In the next example, I will show how to have indirect access to a private attribute using setters and getters: {
        #name; (name)  { .#name = name; .getName = .#name; .setName = { (newName.length> ){ .#name = newName;
                } { .log( );
                }
            }
        }
    } person = Person( , ); .log(person.getName()); person.setName( ); .log(person.getName()); person.setName( ); class Person //must be declared constructor this this => () this this ( ) function newName if 0 this else console "invalid name" let new "oscar" "porras" console //oscar "andrés" console //andrés "" //invalid name You must use "#" to declare a private variable or method. Once declared, you cannot edit or read this variable just by using its name. If you need to edit or read this variable you will need to use the get and set methods. In the example, I created the method "getName" and "setName" to read and write the private variable. Notice that the write method doesn't allow you to edit if the new name length is 0. CONCLUSION As a software developer, working with OOP language, you must never forget these four concepts: inheritance, abstraction, encapsulation, and polymorphism. Pure theoretical definitions can be confusing the first time, that's why I like explaining with examples. Never forget trying to use these core ideas in your code, if you can apply them then probably is because you should do it.

Introduction to OOP in Javascript

The Object-Oriented Design Principles are the core of OOP programming, but I have seen most of the Java programmers chasing design patterns like , , or , and not putting enough attention on learning . Singleton pattern Decorator pattern Observer pattern Object-oriented analysis and design It’s important to learn the basics of Object-oriented programming like , , , and . But, at the same time, it’s equally important to know object-oriented design principles. Abstraction Encapsulation Polymorphism Inheritance They will help you to create a clean and modular design, which would be easy to test, debug, and maintain in the future. I have regularly seen Java programmers and developers of various experience level, who have either never heard about these and or simply doesn’t know what benefits a particular design principle offers and how to apply these design principle in coding. OOP SOLID design principle , To do my part, I have jotted down all important object-oriented design principles and putting it here for quick reference. These will at least give you some idea about what they are and what benefit they offer. I have not put examples, just to keep the article short but you can find a lot of examples of these design principles on the internet and even on my , just use the search bar at the top of the page. Java blog If you are not able to understand a design principle, you should try to do more than one example because sometimes we connect to another example or author better but you must understand these design principles and learn how to use it in your code. Another thing you can do is to join a comprehensive object-oriented design course like by Steve Smith on Pluralsight. It has helped me a lot in my understanding and application of these principles. SOLID Principles of Object-Oriented Design Btw, I have shared some relevant and useful courses and books here and there, both free and paid, and I will earn some money if you buy something which is not free. They are also some of the resources I have used to learn SOLID design principles and Programming in general and nice for learning some of these principles in depth. 10 Object Oriented and SOLID Desing Principles for Programmers Though the best way of learning any design principle or pattern is a real-world example and understanding the consequences of violating that design principle, subject of this article is Introducing for Java Programmers, who are either not exposed to it or in the learning phase. Object-oriented design principles I personally think each of these and needs an article to explain them clearly, and I will definitely try to do that here, but for now, just get yourself ready for a quick bike ride on design principle town :) OOP SOLID design principles 1. DRY (Don’t repeat yourself) Our first object-oriented design principle is DRY, as the name suggests means don’t write duplicate code, instead use to abstract common things in one place. DRY (don’t repeat yourself) Abstraction If you have a block of code in more than two places consider making it a separate method, or if you use a hard-coded value more than one time make them . The benefit of this Object oriented design principle is in . public final constant maintenance It’s important not to abuse it, duplication is not for code, but for functionality. It means if you have used common code to validate OrderId and SSN it doesn’t mean they are the same or they will remain the same in future. By using common code for two different functionality or thing you closely couple them forever and when your OrderId changes its format, your SSN validation code will break. So beware of such coupling and just don’t combine anything which uses the similar code but are not related. You can further check out the in Java course on Udemy to learn more about writing good code and best practices to follow while designing a system. Basics of Software Architecture & Design Patterns 2. Encapsulate What Changes There is only one thing which is constant in the software field and that is “Change”, So, encapsulate the code you expect or suspect to be changed in future. The benefit of this OOP Design principle is that It’s easy to test and maintain proper encapsulated code. If you are coding in Java then follow the principle of by default and increasing access step by step like from a private to and not . making variable and methods private protected public Several of the uses Encapsulation, the is one example of Encapsulation which encapsulates object creation code and provides flexibility to introduce a new product later with no impact on existing code. design patterns in Java Factory design pattern Btw, if you are interested in learning more about design patterns in Java and Object Oriented Programming then you must check this course Pluralsight. It’s one of the best collection of design patterns and advice on how to use them in the real world. Design Pattern Library 3. Open Closed Design Principle According to tho this OOP design principle, “Classes, methods or functions should be Open for extension (new functionality) and Closed for modification”. This is another beautiful SOLID design principle, coined by Uncle Bob on his classic book, which prevents someone from changing already tried and tested code. Clean Code The key benefit of this design principle is that already tried and tested code is not touched which means they won’t break. Here is a Java code example which the Open Closed Design Principle of Programming: violates In this code GraphicEditor is tightly coupled with Shape, If you need a new Shape then you need to modify already tried and tested code inside thedrawShape(Shape s) method, which is both error-prone and not desirable. Ideally, if you are adding new functionality only than your code should be tested and that’s the goal of . Open Closed Design principle By the way, the Open-Closed principle is “O” from the SOLID acronym. If you want to learn more about this principle, the course on Udemy is one of the best resources to consult. SOLID Principles of Object-Oriented Design and Architecture 4. Single Responsibility Principle (SRP) Single Responsibility Principle is another SOLID design principle, and represent “S” on the SOLID acronym. As per SRP, there should not be more than one reason for a class to change, or a class should always handle single functionality. The key benefit of this principle is that it reduces coupling between the individual component of the software and Code. For example, If you put more than one functionality in one Class in Java it introduces between two functionality and even if you change one functionality there is a chance you broke coupled functionality, which requires another round of testing to avoid any surprise on the production environment. coupling You can further see course on Udemy to learn about patterns which are based on this principle. From 0 to 1: Design Patterns — 24 That Matter 5. Dependency Injection or Inversion principle Don’t ask for dependency it will be provided to you by the framework. This has been very well implemented in , one of the most popular Java framework for writing real-worth applications. Spring framework The beauty of this is that any class which is injected by DI framework is with the mock object and easier to maintain because object creation code is centralized in the framework and client code is not littered with that. design principle easy to test There are multiple ways to implemented like using bytecode instrumentation which some AOP (Aspect Oriented programming) framework like AspectJ does or by using proxies just like used in Spring. Dependency injection You can further see the course on Udemy to learn more about this useful principle. It also represents “D” on the SOLID acronym. SOLID Principles of Object-Oriented Design and Architecture Here is an example of the code which violates Dependency Inversion Principle or DIP in Java: You can see that AppManager depends upon EventLogWriter which is tightly coupled with the AppManager. If you need to use another way to notify your client like by sending push notifications, SMS, or E-mail, you need to change the AppManager class. This problem can be solved by using the Dependency Inversion Principle where instead of AppManager asking for EventLogWriter, it will be injected or provided to AppManager by the framework. You can further see on Udemy to learn more about the Dependency Inversion Principle and how to solve such problems. Using SOLID Principles to Write Better Code — A Crash Course 6. Favor Composition over Inheritance There are two general ways to reuse the code you have already written, Inheritance and Composition, both have their own advantage and disadvantages, but, in general, you should always favor composition over inheritance, if possible. Some of you may argue this, but I found that is the lot more flexible than . Composition Inheritance Composition allows changing the behavior of a class at run-time by setting property during run-time and by using Interfaces to compose a class we use which provides flexibility to replace with better implementation any time. polymorphism Even Joshua Bloch’s advise favoring composition over inheritance. If you are still not convinced then you can also read to learn more about why your Composition is better than Inheritance for reusing code and functionality. Effective Java here And, if you keep forgetting this rule, here is a nice cartoon to put in your desk :-) If you are interested in learning more about Object Oriented Programming Concepts like Composition, Inheritance, Association, Aggregation, etc, you can also take a look at the course on . Object-Oriented Programming in Java Coursera It’s free to explore and learn but you will be charged if you also want to participate in exercises, assignment, evaluation and need Certification to show in your LinkedIn profile. 7. Liskov Substitution Principle (LSP) According to the Liskov Substitution Principle, Subtypes must be substitutable for supertype I mean methods or functions which uses superclass type must be able to work with the of subclass without any issue”. object LSP is closely related and . to the Single responsibility principle Interface Segregation Principle If a class has more functionality than subclass might not support some of the functionality and does violate LSP. In order to follow , derived class or subclass must enhance functionality, but not reduce them. LSP represents “L” on the SOLID acronym. LSP SOLID design principle Here is a code example which violates the Liskov Substitution Principle in Java: Liskov Substitution Principle in Java If you have a method area(Rectangle r) which calculates the area of Rectangle then that code will break when you pass the Square because Square is not really a Rectangle. If you are interested in a more real-world example, then the course on Pluarlsight is a good course to start with. SOLID Principles of Object-Oriented Design Btw, you would need a Pluralsight membership to get access this course, which cost around $29 per month or $299 annually (14% discount). Even if you don’t have a membership, you can still access this course for FREE by taking advantage of their without any commitment, which is a great way to not just access this course for free but also to check the quality of courses before joining Pluralsight 10-day free trial 8. Interface Segregation Principle (ISP) Interface Segregation Principle stats that, a client should not implement an if it doesn’t use that. interface This happens mostly when one interface contains more than one functionality, and the client only needs one functionality and no other. There is no doubt that Interface design is a tricky job because once you release your interface you can not change it without breaking all implementation. Well, Java 8’s feature does provide a way for interface evolution but not all Programming language support that features. default or defender method Another benefit of this design principle in Java is, the interface has the disadvantage of implementing all method before any class can use it so having single functionality means less method to implement. If you don’t the get the benefit of the interface in coding then I suggest you read my blog post, the to learn more. real usage of an interface in Java 9. Programming for Interface not implementation A programmer should always this will lead to flexible code which can work with any new implementation of the interface. program for the interface and not for implementation In concrete words, you should use interface type on variables, return types of a method or argument type of methods in Java like using SuperClass type to store object rather using SubClass. I mean List numbers= getNumbers(); instead of ArrayList numbers = getNumbers(); This has also been advised in many Java books including in and book. Effective Java Head First design pattern Here is an example of Coding for the interface in Java: If you are interested in improving code quality of your program, I also suggest you take a look at the course on Udemy which will help you to improve the internal design with refactoring techniques and design patterns in C# Refactoring to Design Patterns 10. Delegation principles Don’t do all stuff by yourself, delegate it to the respective class. Classical example of delegation design principle is . equals() and hashCode() method in Java In order to compare two objects for equality, we ask the class itself to do comparison instead of Client class doing that check. The key benefit of this design principle is and pretty easy to modify behavior. Event delegation is another example of this principle, where an event is delegated to handlers for handling. no duplication of code Summary All these help you write flexible and better code by striving high cohesion and low coupling. object-oriented design principles The theory is the first step, but what is most important is to . develop the ability to find out when to apply these design principles Once you get hold of that, the next step is to learn Design patterns in Java, which uses these design patterns to solve common problems of application development and software engineering. If you are looking for a nice course to start with, I suggest you join the course on Udemy. It’s very comprehensive and you can get it in just $11 on their several flash sales. From 0 to 1: Design Patterns — 24 That Matter — In Java Anyway, here is a nice summary of all these OOP design principles. Find out, whether we are violating any design principle and compromising the flexibility of code, but again as nothing is perfect in this world, don’t always try to solve the problem with they are mostly for large enterprise project which has longer maintenance cycle. design patterns and design principle Bottom line is, professionals programmers should always strive for a highly cohesive and loosely couple solution, code or design. Looking open source code from Apache and Google are some good ways of learning and . Java OOP design principles They will show you, how design principles should be used in coding and Java programs. Java Development Kit follows many design principles like in BorderFactory class, in java.lang.Runtime class, on various java.io classes. Factory Pattern Singleton pattern Decorator pattern If you are interested in learning object-oriented principles and patterns, then you can look at my another personal favorite , an excellent book and probably the best material available in object-oriented analysis and design Head First Object-Oriented Analysis and Design Not many programmers know this book because it is often shadowed by its more popular cousin by , which is more about how these principles come together to create a pattern you can use directly to solve known problems. Head First Design Pattern Eric Freeman These books help a lot to write better code, taking full advantage of various Object-oriented and SOLID design principles. Btw, if you really interested more in Java coding practices then read by Joshua Bloch, a gem by the guy who wrote Java Collection API. Effective Java 3rd Edition If you want to learn more about SOLID design Principles, here are some useful resources you can take a look: By Clean Code Robert Martin SOLID Principles of Object-Oriented Design SOLID Principles of Object-Oriented Design and Architecture Refactoring by Martin Fowler And, if you like this article, you may like these : Java and Programming articles as well 10 Things Java Programmer should learn in 2019 10 Books Every Programmer Must Read 10 Tips to Improve Your Programming skill 10 Tools Every Software Developer should know 5 Courses to Learn Software Architecture in Depth 20 Libraries and APIS Java Programmer Should Know Top 10 Programming languages to Learn in 2019 10 Framework and Library Java and Web Developer Should Learn Thanks for reading this article. If you find these object-oriented design principles useful then please share with your friends and colleagues. If you have any questions or feedback then please drop a note. Btw, if you buy any of my recommended book or course, I’ll be also be paid. If you like this article then please consider following me on medium ( ). if you’d like to be notified for every new post and don’t forget to follow on Twitter! javinpaul javarevisited If you are really passionate about your Coding and want to improve your coding skill there are no better books then by and Refactoring by . Just go and read them. P. S. — Clean Code Robert Martin Martin P. Fowler

OKOP SHOW

tiktok.com

-- employees

Since n.d.

COMPANY RANKING

OKOP SHOW

EVERGREEN INDEX #8013

Representing this company? Click here to claim and customize this page!

OKOP Show WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!

OKOP SHOW

tiktok.com

-- employees

Since n.d.

COMPANY RANKING

OKOP SHOW

EVERGREEN INDEX #8013

RELATED COMPANIESRANK

STORIES ABOUT OKOP SHOW

Representing this company? Click here to claim and customize this page!

OKOP Show WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!