diff --git a/.idea/NodeJSBlog.iml b/.idea/NodeJSBlog.iml new file mode 100644 index 0000000..24643cc --- /dev/null +++ b/.idea/NodeJSBlog.iml @@ -0,0 +1,12 @@ + + + + + + + + + + + + \ No newline at end of file diff --git a/.idea/modules.xml b/.idea/modules.xml new file mode 100644 index 0000000..b6df6ff --- /dev/null +++ b/.idea/modules.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/entries/hardware/media/2ac00ccdcae9b672a2f844b7f8f318c5.png b/entries/hardware/media/2ac00ccdcae9b672a2f844b7f8f318c5.png new file mode 100644 index 0000000..ad6e7c7 Binary files /dev/null and b/entries/hardware/media/2ac00ccdcae9b672a2f844b7f8f318c5.png differ diff --git a/entries/hardware/media/31210e78cc2cae122a6c3fdb93ab87c0.png b/entries/hardware/media/31210e78cc2cae122a6c3fdb93ab87c0.png new file mode 100644 index 0000000..2c71602 Binary files /dev/null and b/entries/hardware/media/31210e78cc2cae122a6c3fdb93ab87c0.png differ diff --git a/entries/hardware/media/3812f5e41805eb999b057c15bae19081.png b/entries/hardware/media/3812f5e41805eb999b057c15bae19081.png new file mode 100644 index 0000000..b141e7d Binary files /dev/null and b/entries/hardware/media/3812f5e41805eb999b057c15bae19081.png differ diff --git a/entries/hardware/media/d460663e2f964c76a15d2c07a7052d60.png b/entries/hardware/media/d460663e2f964c76a15d2c07a7052d60.png new file mode 100644 index 0000000..9713ebc Binary files /dev/null and b/entries/hardware/media/d460663e2f964c76a15d2c07a7052d60.png differ diff --git a/entries/hardware/media/f19479753c6d86855a3a77f1cf840942.png b/entries/hardware/media/f19479753c6d86855a3a77f1cf840942.png new file mode 100644 index 0000000..85df9ba Binary files /dev/null and b/entries/hardware/media/f19479753c6d86855a3a77f1cf840942.png differ diff --git a/entries/programming/media/90703af9527d8d4aecc7eefbda5f049a.png b/entries/programming/media/90703af9527d8d4aecc7eefbda5f049a.png new file mode 100644 index 0000000..4e4e59b Binary files /dev/null and b/entries/programming/media/90703af9527d8d4aecc7eefbda5f049a.png differ diff --git a/entries/programming/using-english-conventions-to write-clean-code.md b/entries/programming/using-english-conventions-to write-clean-code.md new file mode 100644 index 0000000..dba7e41 --- /dev/null +++ b/entries/programming/using-english-conventions-to write-clean-code.md @@ -0,0 +1,177 @@ +Is that English? +``` +private boolean canCompressBlock(Coordinate start, int size){ + return size == (int)Arrays.stream(this.rawImage, start.getRow(), start.getRow() + size) + .filter(r-> size == (int)Arrays.stream(r, start.getCol(), start.getCol() + size) + .filter(c-> c == this.rawImage[start.getRow()][start.getCol()]) + .count()).count(); +} +``` + +After 30 minutes of brain boiling work, I finally finished crafting the most +beautiful lambda statement in Java. What could have simply been done in two +nested for loops, I decided to tackle the problem with the infamous lambda +statement-- feared by most programmers. Lambda statements by no stretch makes +code any easier to read since the same tasks can be accomplished through using +simpler and more recognizable syntax. Yet I decided to utilize this excessive +lambda statement. After much contemplation, I realized that I was only using +lambda statements due to the fact that people inside of a field typically try to +write to impress their peers. This code chunk is clearly a sophisticated use of +functional programming and will likely impress people inside the computer +science community; however, 95% of my computer science class would not +understand a single word of this statement. This poses a dilemma to newer +programmers which may have difficulty reading this “sophisticated code”. After +years of helping students learn to program in my high school, I know that +students struggle with making their own code legible. Their code often lacks +sophistication and clarity. However, at the same time many of my college +professors which are embedded in the field of computer science often write code +that is too sophisticated and obscure for anybody to easily understand. This got +me thinking, how can we teach students to programming in a way that yields +legible code for everybody in the computer science field? I turned towards +English. It turns out that programming can take a few pointers from English to +improve its clarity. The same skills used to teach writing can be applied when +teaching students to program because excellent code and writing contains thought +through structure, clear phrasing and readability. + +The role that composition has in programming is disputed. There are people that +gravitate towards programming in college because it is math and science +intensive. Traditionally, programming has been viewed solely as a science. Some +people may argue that composition does not play an influential role in +programming. Computers are rocks that we tricked into manipulating data for us. +However, language is inescapable and finds a way to seep into every facet of our +lives. Once we recognize the similarities that programming and English +composition have, we can move towards writing more comprehensible code. If you +ignore the parallels between writing and coding, you are disconnected from +relationships that can further enhance your code. Tom Lynch concluded in his +article “Letters to the Machine: Why Computer Programming Belongs in the English +Classroom”, “If English class is where our children already learn how to +critically engage with language, adding computational languages is a natural +complement”(96). The same skills that we have been developing for hundreds of +years to teach English can also be applied when teaching programming. + +Structure is the first thing that can make or break a writing assignment or an +extensive programming project. There is nothing more cringe inducing than +sitting down to read an essay only to quickly realize that is just all heaped +into one massive body paragraph. The same is true with programming, students try +to jam all their code into a single method like an overpacked suitcase. +Typically teachers try to prevent the slaughter of an essay by giving students a +graphical organizer to fill out before the pens strike paper. The most notable +essay organizers represent the introduction as an upside-down triangle and body +paragraphs as rectangles. The triangles helps the students visualize the +specificity of details and the partitioning forces the separation of ideas into +paragraphs. It turns out that this technique also yields success in teaching +students structure in computer science. In Vincent’s master thesis he noted +“Results indicated that when students went on to their second level programming +course, the students who were provided templates wrote better code. The code +they wrote was more modular, used more effective parameter passing, and was +better documented”(63). Computer science students are provided with “skeleton +code” where the classes and method headers are provided, but, the students have +to implement the methods. This teaches students to make both methods and classes +homogeneous. In other words, functions should perform one task and should be +under 30 lines long. Functions are a lot like sentences in English where they +should convey a single message. Classes comprise both variables and functions +and should only express one idea -- a lot like a paragraph. You might be +wondering why students struggle with structure in writing when they are provided +ample templates by their teachers. In his essay “Pay Attention to the Man Behind +the Curtain: The Importance of Identity in Academic Writing” Williams states +that “Many students are taught that using the five-paragraph essay form with any +semblance of identity removed is the core of academic writing and will allow +them to march triumphantly through the writing assignments of one class after +another”(Williams 711). The truth is, writing and programming does not always +follow strict structural guidelines. Just like always writing five paragraph +essays is not always the optimal solution for essays, templates also fail in +programming. As much as we love to provide students with nifty templates to +follow, there will come a day when students have to think outside of the box and +formulate their own structure. Programming students need more exercise where +they learn to structure their code into methods and classes. A good example of +such an exercise would have students separate a cluttered chunk of code into +methods and classes. I am not suggesting that teachers should not use templates +to teach structure to students; however, I believe that the templates used +should not be stressed as the only or best solution. + +Both concise composition and programming uses clear diction. It is frustrating +when you read an essay and it does not register because the concepts were +inefficiently conveyed. This is a major issue in both writing and programming. +There are simple forms of misleading phrasing that distracts the user from the +intended message. The simple use of obscure verbs or rambling may distract the +reader from the intended topic. Code and literature are competing for your +finite attention when conveying a message. If you have to read a programming +project multiple times before understanding it, its phrasing is probably poor. +An effective way that both English major and Computer Science majors can try to +improve phrasing is through peer reviews. In peer reviews it becomes obvious +which parts of your projects are hard to understand. In his paper “Letters to +the Machine: Why Computer Programming Belongs in the English Classroom” Lynch +noticed that as students become more comfortable with the computer dialect, they +imagined how their audience would respond to what they wrote”(96). Programs, +although ran on the computer are meant to be read and analyzed by other people. +People can make their programs more readable through documentation, clear +variable, and helper methods. Most inexperienced programmers use terrible +variable names which have no relationship to what they are storing. Take the +following example: +``` +String s1; +String s2; +String s3; +``` + +``` +String firstName; +String middleName; +String lastName; +``` + +Someone skimming over the code on the top you would have no clue what the +strings stored and would have to tear apart the program to figure out. The +example on the bottom is crystal clear on what the variables are meant to store. +Like programming students, inexperienced writers tend to struggle with using +sources to support their arguments in their essays. Just like programmers lack +documentation which informs the reader about what the program is doing, +inexperienced writers have a hard time using sources in their essay to support +their claims. In article “I Just Turned In What I Thought” Anne Elrod Whitney +examined a particular student as he struggled to find a balance between personal +ideas and sources when writing an essay(188). Although programmers and writers +may know what they are talking about, they also need to communicate those ideas +with the reader through ample sources and documentation. +``` +\++++++++[\>++++[\>++\>+++\>+++\>+\<\<\<\<-]\>+\>+\>-\>\>+[\<]\<-]\>\>.\>---.+++++++..+++.\>\>.\<-.\<.+++.------.--------.\>\>+.\>++. +``` +Would you believe me if I told you that the segment of code above this sentence +when ran in a Brainfuck compiler prints “Hello World”? +``` +print("Hello World") +``` +This programming segment also prints “Hello World”, but in Python. There is a +large variation in programming languages. However, most high level programming +languages like Python and Java are much more readable than Brainfuck. A buzz +word in the computer science field is “abstraction”. Abstraction is the process +of simplifying complicated processes into something more understandable. The +example in the top of the paragraph deals with manipulating memory registers to +become the ascii values of “Hello World”. The problem with Brainfuck is that +whenever you program for it, you have to translate every concept into a byte +array. Computer scientists solve this problem by making higher level programming +languages like Python and Java which takes care of mundane tasks under the hood. +Vincent in his master thesis noticed that “Given the similarities between spoken +languages and object-oriented programming languages that have emerged, there is +much encouragement that there may be possibilities for a new instructional +paradigm”(5). Higher level programming languages are starting to share a +shocking number of similarities with English. With these new levels of +abstraction, programmers are able to focus less on syntax and more on +structured, problem solving and documentation which enables larger teams of +programmers to work together with clarity. + +When you start treating code as an extension of the English language rather than +a scientific construct, you start to write more understandable code. A few days +ago a friend of mine asked me for help on a large programming project the night +it was due. My brain groaned as I scanned his project, the bulk of the code was +jammed into an ugly 300-line undocumented method. The variable names were +obscure and there were so many nested statements that the code started to tail +off the screen. I was unable to decipher what was happening in his program. All +I could do for him was suggest how he could clean up his code and restructure +his project so that he can understand what is happening where. It is hard to +solve a bug when even the author has difficulties deciphering what is happening +in the code. Programming is another form of communication that needs to be +treated similarly to composition. The computer does not care what you write; +however, it is critical that your audience is able to understand what you are +saying with clarity and precision. + +![](media/90703af9527d8d4aecc7eefbda5f049a.png)