DEV Community: Zachary Hadjah

The Efficiency of Role Based Security

Zachary Hadjah — Fri, 23 Apr 2021 15:07:25 +0000

Authentication is the process of logging into an application. A user cannot login until they have proven that they have created an account within the application. Once an account has been created, they can prove to the application that they are a registered user.

Authorization deals with the level of access one individual holds.

Only after a user creates a profile, can the application authenticate it. The application now needs to assign a level of authorization to each and every user that has a profile. The best way to describe how levels of authorization are assigned is by using a bank as an example.

In the above scenario, you have one system, five roles. If you have 10,000 users authenticated into your system, each one of the 10,000 needs a role no matter what the circumstance.

Least Privilege Principle -
Every account that is created inside of an application should operate only on a need-to-know basis. Other factors such as job position or level of supervision will also factor into the amount of privilege given to certain roles.

Lets work with the Client and Admin accounts since it will be easiest to assess their privileges. First, the admins are the ones in charge of everything IT-related in the system. It falls on them to oversee all IT Operations such as ensuring all users gain access to the documentation or processes they require. Some examples of documentation the admin would have access to are social security numbers of clients, the employee number of developers and bank staff, or top-secret company information that may require a clearance. Admins need to know the state of IT Operations across the entire application, meaning they will operate from a high privileged role. This high privileged role will allow admins to have certain rights that most users in the applications will not gain access to. On the opposite side of the spectrum, the client will be in the least privileged role since they will not have access to information that pertains to other members of the application. Clients will only be allowed to access information that pertains to themselves such as their bank statements, routing and account numbers, etc. The Least Privilege Principle will also be used to assess the roles of the bankers, supervisors, and developers as well.

Allowing user roles to be the main method of security can be applied to various contexts within engineering. When creating my bug tracker application in .NET5 using the MVC design pattern, I would assign each user a different role based on their privilege and what they’d need to know. The bug tracker featured roles that mimicked an actual software development team. A demo user role was added as a way to have clients interested in the app to quickly demo it without needing to use their personal info to sign in.

To enforce that the only users who have access to the application are authenticated, in C#’s MVC structure, you can use the authorize decorator above the entire index action like so:

User principal claims can also be used in order to keep track of certain roles.

Role based security is also a leading technique in cloud computing as well. Microsoft Azure AD allows Administrators to use the same principles when creating domains. You can create roles and give certain privileges to roles based on a need to know basis within the domain. In the case of Azure and cloud computing, high privileges granted to users would result in more Azure services they would be able to perform. Microsoft also tends to refer to this as Role Based Access Control (RBAC).

https://docs.microsoft.com/en-us/azure/role-based-access-control/overview

How Technical Recruiters can better interact with Developers

Zachary Hadjah — Mon, 29 Mar 2021 14:41:03 +0000

Before accepting my current position, I had been networking with recruiters all over LinkedIn. After having hours worth of interactions, I decided I could shed some light on how recruiters could better interact with developers and achieve a higher success rate.

The same way recruiters are always looking for keywords, we developers are as well! Though they may recruit for multiple companies using multiple languages, recruiters often times have 2 or 3 companies in which they work closely with. Putting keywords in their Linkedin headlines can prove very helpful.

Having a basic understanding of the technology and what it does can also bridge the gap between both parties. For the recruiters reading, here is a basic run down:

Fullstack = Frontend and Backend

Frontend:
What the customer sees. React, Angular, Vue, HTML, CSS, and Bootstrap to name a few. These languages are used to create what the customer will see on screen.

Backend:
What the server executes. Java, C#, .Net, Ruby, Python, and many more. These languages will be used on the server side and will not be viewed by the customer.

SQL:
Anything pertaining to SQL will hold information inside a database such as all the bank accounts in a banks system, or all the students in a university.

DevOps:
Dev = Software Development
Ops = IT Operations
How software is managed.

CICD:
Dev Ops tactic used to maintain working code.

Github:
Where we store all of our code so it doesn’t get lost.

Another way recruiting agencies could boost their placement percentages and have a higher success rate is to cultivate good partnerships with the interviewers who will be asking questions to candidates. As this partnership grows, eventually have the senior technical recruiter ask if they can sit in on interviews.

Back in February, a recruiter from Apex Systems had contacted me about an interview with Microsoft. During the interview, the Senior Technical Recruiter of the Dallas Forth Worth office had attended the interview since it was virtual over Microsoft Teams. Since she sat quietly in the interview and observed, she can now better prep subsequent candidates on how Microsoft conducts its interviews. She'll know what behavioral questions are asked, what technical questions are asked, what some of the harder questions are, etc.

Recruiters are hired for their ability to sell candidates. If a candidate states their salary range of $100k - $120k, it's the recruiters job to get the candidate the $120k asking price. When sourcing potential candidates, focus on the candidates who are properly selling themselves on LinkedIn. Experience, extracurricular projects, articles and portfolio websites are all metrics you should use to gauge when cold messaging or filtering resumes. These four metrics can speak volumes as to how eager developers can be. Experience alone cannot replace eagerness. I've heard stories of senior developers walking out of interviews because they believed they were above some of the technical questions being asked of them in interviews. Candidates constantly showcasing their material on social media are the ones you should be focused on. Those candidates feel as though they need to prove themselves and will be attentive when you give them instructions to follow in order to secure a job offer.

Also, pay close attention to the stories of candidates and where they originate from. If you see a trend of students from UMASS Amherst getting job offers, or students from a specific Bootcamp being placed, it may be a good idea to reach out to the instructors of the institution in order to cultivate a relationship. This way, instead of prepping candidates 3 days before an interview, you'll have time to prep candidates 3 or 4 months ahead of their interviews. Look at this as an investment, you are investing in the candidate and your office’s growth.

One way you can prep future candidates is to have them set up portfolio sites. Portfolio sites are essential to showcasing one’s skill. These websites can even be created using a template in which the developer can modify with simple bootstrap knowledge that can be learned in a weekend. Themeforest and wrapbootstrap.com are two of the top websites when it comes to bootstrap portfolio templates. Next, have candidates write articles about CICD, source control, design patterns they are learning, or about some of the other keywords that you often see in resumes. Back in March, I went on an interview with a CEO of a company that I came across. After reading some of my articles and having a talk with him, he was kind enough to let me know that he had written this post with our interview in mind:

Encouraging your network of future candidates to write articles on their areas of expertise makes it easier for employers to quickly identify competence in the candidate's skillset. Have them publish their articles either here on dev.to or on a personal blog site they create. Also have them link their articles and projects on their resume aswell.

When you and the candidate are in the process of setting up an interview with a hiring manager, make sure you notify the candidate to have a pen and paper. If the interviewer asks a question in which they don't know the answer, they must write it down. On top of the questions they don’t know, tell them to jot down some of the questions that they do know but were a little bit harder to articulate. Call the candidate 20 minutes after the interview, ask them how it went, and have them look up the answers to the questions they failed to answer properly. Once they’ve researched the answer, ask them to email the answer to you, and subsequently, email the answer to the interviewer as soon as possible. Now, instead of giving a soft no, the interviewer may reconsider giving the candidate a second look, and you’ve just learned one of the questions that will be asked to candidates on the next round of interviews.

Below is an example of how I've linked my projects and articles onto my resume:
https://drive.google.com/file/d/1yR0VR0YP9vgsdqeRXfeKod4FiwiYE3_J/view

How Senior and Mid-level developers can better teach Juniors

Zachary Hadjah — Sun, 14 Mar 2021 00:02:14 +0000

Coder Foundry has helped me realize my passion for learning and helping others learn. The Bootcamp is a twelve-week intensive job skills course focused on placing participants into the tech industry. Some participants had no previous knowledge of coding while others had backgrounds in IT. Though I'm still learning, I've been able to identify certain methods that can help students eager to learn.

 Show, don't tell.

The owner of the Bootcamp, Bobby Davis Jr, has a video on youtube describing how one full-stack project can lead to a dev job. The video explains what a bug tracker is and what technologies were used to build it. I did some research on LinkedIn and saw the bug trackers of Coder Foundry graduates. They were all functional and had crisp user interfaces. I decided to give it a shot. After watching Bob Tabor's 8 hour video on the C# fundamentals, I bought a Udemy course and started learning from tutorials how the MVC design pattern works. From there I went onto Youtube and started searching for the best-looking bootstrap templates. Next, I began setting up sprints, user stories, and Software Requirement Specifications. Lastly, as I worked on the project I would consult senior-level developers from discord chats and websites such as codementor.io for guidance and code review.

I got far into building the bug tracker, solely based on everything I had seen and heard from Bobby’s video. I eventually decided to enroll myself into a cohort to fully flesh out my bug tracker as well as my full-stack skills. Show the learner, and if they are truly eager to learn, they'll find a way to hone their skills.

 Use real-world examples

Most students looking to get into software development aren't familiar with technical jargon. You need to ease them into it. I was recently paired up in a zoom breakout room during our final weeks of the cohort. "What are the differences between classes, services, and models?" When this question came up, I paused for a second before giving an answer. Though it was a long-winded answer, it seemed to click. I also decided to give an example just to solidify the theory.

"Classes are blueprints that will hold methods and properties (or fields). Services are classes that will perform certain functions. Think of services as a verb. Models are classes that will take on the shape of data in which records will be created and put into a database. The records that get put into a database could be records of students, teachers, or principals. Think of models as a noun."

This example seemed to click a lot more. Nouns and verbs are things we have been learning since kindergarten. Another real-world example I used to help a fellow student was when it came to abstraction. Lets be honest, the word abstraction itself can seem intimidating. Instead of abstract, let's use something a little more beginner-friendly.

Extract.

Vanilla extract, Almond extract, Pepper extract. Think about the process of extracting vanilla out of a vanilla bean. You are taking the flavor of the vanilla bean, and processing it into a new form. It may be in a different form, but it is still the same vanilla flavor.

var abstract = new Extract();

When you abstract(Extract) logic from a controller and put it into a service, you are taking that logic from the controller and using it in a manner that will be easily accessible and optimal for the application.

If you wanted to take it further, you could even tie in loose coupling to this example. PepsiCo, parent company of many famous beverage brands, wants to go into the health foods industry. They want to create a new beverage that will serve as a pomegranate smoothie. Since pomegranate seeds leave chunky residual when blended, to achieve a smooth consistency, PepsiCo has decided that their pomegranate flavors will be made from concentrated EXTRACTS. The company needs their beverages to be smooth and LOOSE to appease the customer's expectations when it comes to consistency.

OOP development always needs to adhere to loose coupling as opposed to something densely packed and tightly coupled. A loosely coupled application is a lot easier to maintain since developers will be able to easily trace the flow of data and quickly set breakpoints.

  Create Toy Apps

Before joining Coder Foundry, my GitHub repo was filled with toy applications. Toy apps are applications you build to get your feet wet, NOT applications you show employers to secure a job offer. TicTacToe, ToDo Lists, and calculator apps are all examples of toy apps. Again, if you showed this to an employer hoping to impress them, they will most likely give you a soft no. However, if you created a console application and build a toy app that implements a list, chances are, you'll have an easier time working with lists when the interviewer asks you to print out a list's elements in alphabetical order.

Back in December, I created a console application that would print out the number of entries into the Fibonacci series based on the user's input. I implemented a list to store all the entries that were going to be displayed to the user.

Fast-Forward nearly three months later, that same exact Fibonacci toy app helped me secure my first job. It wasn't just the toy app however, it was a scaled-up version of the toy app. I implemented the Fibonacci algorithm as a service inside an MVC application as well as implemented two new services. One service calculates the Pythagorean theorem of two numbers and the other calculates the standard deviation of multiple numbers. I then created XUnit tests for all calculation methods to showcase Test Driven Development methods used in the industry. Lastly, I logged info from the application to a seq server utilizing Serilog structured logging.

P.S.
Shout out to the creator of Seq for giving me feedback :)

Have Junior developers watch Youtube videos and read blog posts

Tim Corey is a .NET developer who posts educational youtube videos. I came across his video in which he details 10 NuGet packages that make development easier. FluentAssertions, Serilog, and Seq all stood out as the most useful. During the cohort, I would tell folks that if they had trouble understanding how to implement a certain piece of functionality, to watch youtube videos. Watching videos is good to understand how the functionality works, but can be bothersome when trying to implement. After watching youtube videos, reading blog posts should be the next step. I watched Tim Corey's videos on all three technologies to get a sense of what to do, gave it a shot. Next,I started reading blog posts from other developers to compare and contrast my code with theirs. Open source blog posting websites are amazing because developers are very willing to interact with their comments section. Devs love knowing that they are helping other devs while also displaying their expertise to potential employers.

I showcased the MVC app (as well as my bug tracker) at multiple interviews and was lauded for my efforts.

https://tdddemo.herokuapp.com/

An article will be written later on detailing my experience with Serilog, Seq, XUnit tests, and FluentAssertions. Check out some of my previous experiences: https://zacharyhadjah.netlify.app

Implementing and Troubleshooting Microsoft's Identity Framework

Zachary Hadjah — Sun, 31 Jan 2021 22:38:37 +0000

Ever since freshman year, one of the best skills I’ve honed as a developer is identifying and making sense of patterns and frameworks first, and then figuring out the proper logic statements to implement them into programs. Before applying to Coder Foundry, I decided to take a shot at making the bug tracker. Though I was able to understand the architecture and frameworks being used, I still made a lot of mistakes when working on the application the first time through. This forced me to seek counsel in the form of discord servers, codementor sessions, and hours of reading documentation and watching youtube videos. All those failures have led to my current success and knowledge. The failures allowed me get the stupid questions early and get them out of the way early, so that I can start asking smarter, well formulated questions that were more productive to both me and my mentors. Now I’ve gotten to the point in which I’ve better learned the technology and am able to better explain it, implement it, and help other developers understand it as well.

In order to properly extend the Identity framework, developers must understand the concepts of Authentication and Authorization first. Any website that will allow clients to interact with the application in which certain information will need to be accounted for, will need to give all users an identity, or an account. Developers will put in place certain parameters to make sure that accounts are valid and will not contain malicious commands that can compromise the application or other users. To ensure this, validation is used when the client is creating names, emails, passwords, etc. So to recap, a client has decided to use your bug tracker. The bug tracking application prompts the user to register an account using their first and last name, email, a password, and asks again to confirm the password. All the information the client has entered fits the parameters , and now has an authenticated account. When the developers were creating the application, they made it so that the only clients who are able to see the dashboard of the bug tracker have accounts that are authenticated. As long as the account is authenticated, that client’s account will always be authorized to enter the dashboard of the application. The dashboard of the application will be the avenue to accessing all the features of the bug tracker.

Now that the concept of authentication and authorization has been discussed, let’s discuss the implementation. There is a lot that goes into the Identity framework that developers have to think about based on budget, time constraints, etc. Microsoft has created many classes that developers are about to extend and use in order to fit their application. Because extending the Identity framework can create a lot of files, Visual Studio has created an entire Areas folder. Developers can create a scaffolded item from the identity framework and will then be prompted to choose which files they’d like to override. Again, larger companies may choose to override many files, but for the purpose of this article, we’ll only worry about the login and register pages.

Make note, web pages that pertain strictly to configuring an account (Login, Register, Forgot Password) are called pages, not views. This will be important for developers to understand early just in case an error in the program pops up and the dev team needs to figure out where the bugs are located in the solution explorer. Since we are dealing with the login and register files, they will be present under Account.

The next important step to understanding Identity Framework is by understanding the difference between which files belong to the client-side and which belong to the server-side. The similarities between views and pages can serve a good purpose in order to help the developer distinguish that the .cshtml pages are what the client will see. The .cshtml.cs files belong to the server-side. Take note, when working with other developers, these server-side files can also be referred to as “code-behind” files. Files with the extension .cshtml.cs are considered code behind client-side files.

Microsoft made the decision to have a code-behind for each .cshtml file inside the identity area because each client-side page has so many different functionalities. Below is a picture of how many different client-side pages can be overridden. Since all the pages have different functions, there is no way for the developer to easily handle ten plus controllers and models to manipulate data.

The photo above contains the Register.cshtml form. The user will enter their information into the input fields. The asp- tag helpers are tools that play many roles inside MVC applications. Some asp tag helpers are used for routing the user from one page to another. In this case, the asp-for tag is used to generate name and id elements in markup. Asp-validation-for will show any error messages if the client typed in input that doesn’t properly match validation parameters. Asp-validation-for will attach validation messages onto the input field as long as the property has data validation inside the model. Once the client hits the user submit button, that's when the code behind will execute.

Each code behind will have its own private objects, constructor, bind properties, public variables, and GET/POST asynchronous methods.

The input model will need to match up to the input fields so that data is properly passed between the two.

The Post Asynchronous method is the most important method to understand. This is where the crux of the code behind will execute. All post methods are different but the most important ones will implicitly instantiate classes in order to set certain values into them.

Once the developer has overridden all the parts of identity they have planned on, they can now head back into the controller's file and set the landing page [Controller/Action] to only be accessible by authenticated users.

As stated in the introduction of the article, in order to understand how to troubleshoot issues with identity, the developer must first understand the flow of data. If the developer understands the data flow and where things are being called, they can be able to at least understand where a program’s error is being thrown. In Coder Foundry, a few other students and I would get together and try and help each other troubleshoot our problems as well as implement our ideas. A number of developers seemed to have a fundamental misunderstanding of inheritance. This misunderstanding led to improper naming conventions, incorrect variables being used, and instances being instantiated that contained incorrect forms of data. First off, let's take a look at the bind property.

With the help of some tag helpers, this input property is what will be used inside the .cshtml page in order to dynamically render data. In this case, the properties that would be rendered inside a Register.cshtml.cs page would be Input.Email, Input.Password, and Input.CofirmPassword. While working on our BlogUser projects that required clients to log in and view our blogs, A few developers didn’t understand that the extension of IdentityUser was to store values into the Database, however, you still need to update the input model so that it can take in its default properties as well as take in the extended properties.

After you have added the extended properties, you must then also update your OnPostAsync Property as well. The OnPostAsync property will head into a while loop in which an implicit instantiation of a user will occur. On the right side of the assignment, a lot of developers did not use the right click>Rename action when extending identity. I helped a few go back into the code and help them find the spots in which IdentityUser was defined as opposed to BlogUser.

There were also problems when it came to the private methods and constructors as well.

When it comes to the client-side page issues such as using incorrect tag helpers popped up. Another common issue that happened was when some developers were trying to reference incorrect models from outside of the Identity Area. In order to reference the correct model, you could either directly specify the model if the .cshtml is working with a code-behind like so

           @page
           @model LoginModel

Or you’d need to properly navigate to the model in order to reference it sing dot notation like below:

           @model IEnumerable<OrionBlog.Models.PostComment>

Making sense of the ASP.NET Core MVC Design Pattern

Zachary Hadjah — Sun, 31 Jan 2021 17:32:50 +0000

MVC is a Software design pattern that is used to structure full stack web applications. Visual studio has incorporated frameworks, nuget packages, and libraries to fully support developers when creating MVC apps. This design pattern can be useful for applications in which the following operations are needed:

-Dynamically rendered client side web pages
-Server Side database(s)
-CRUD Actions
-User Authentication
-Authorization

To begin an MVC application, select all the necessary options needed from the templates that Visual Studio has listed inside the user. An ASP.NET Core Web Application will allow users to work cross platform and has a larger set of libraries for developers to work with. Next choosing the ASP.NET Core MVC option with individual user accounts will allow for developers to implement authenication. After the template of the project has been created, The programmer needs to understand the flow of data in order to properly write programs using MVC.

When creating MVC applications, you will always begin building your application from the server side, and then work your way into the client side to ensure that scaffolded classes have been created properly. Models are used in order to mimic real world objects. For example, earlier on in my bootcamp’s Cohort, we built a Car model for a Car Pro mvc application. That Car.cs file will model, or take on the role of, a real life car. Therefore, It will have its own properties that a real life car would have. Make, model, drivetrain, etc. The developer will set these properties to a certain type in order to properly store the values of the properties. Data annotations will be used to curtail data in a manner that is reasonable and easily digestible for both the client and any data structures that may hold onto this piece of data. Since this project will feature a car inside a lot, the car model will contain a foreign key as well as a navigational property to denote its parent. Using this technique of modeling real life objects, Visual Studio will allow us to scaffold a controller that will act as a middleman for the rest of the application.

Using Entity framework, scaffolding a controller from a model will allow the controller to perform CRUD actions, (Create, Read, Update, Delete). The results of the CRUD actions will then be seen inside the View, more on that aspect of MVC later on. As for the controller, CRUD actions are methods the controller uses in order to manipulate the data inside of the models. In MVC, there are two HTTP cycles used in the application, HTTPGET and HTTPPOST. HTTPGET is used whenever a view is being seen by the client for the very First time. For example, if a developer has created an Ecommerce website, the home controller will send an HTTPGET request to the Views file. The views file will send back the index view. Though its not denoted in the method, the very first time the client sees the index page, (denoted as [localhost/home/index]) it is by default an HTTPGET request.

The Views are the client side of the Application. The views will be where the clients will interact with the application. The first thing to understand about the view is the file structure. The home and shared views will always be present at the beginning of any application. The home views have been scaffolded by the home controller. The shared views allow developers to share certain aspects of websites along amongst multiple views. Navbars, sidebars, and many other navigation related components usually reside in the shared folder. Cars and Lots were scaffolded after the Cars and Lots models were created.

The view is responsible for rendering data based on the model that is declared. This is achieved by using a combination of tag helpers, Razor syntax, and lambda expressions. While inside of a view, the user may want to perform a create action. First, the view will show the create method that has the HTTPGET attached to it. Once all input fields inside the form have been completed and the user presses enter, then an HTTPPOST request will be sent to the View. There is a lot going on when a post cycle is being ran. First, the post cycle needs to be ran with an AntiForgeryToken. This validation catches any sort of malicious commands or scripts that could come from an authenticated user. Next, all the properties being created need to be set into the Bind. Think of the bind as a guest list. No name, no entry. All properties of the model, even if it has been set to hidden on the view, need to be inside the bind in order to create a new instance of the model.

The View will then render the index page, [localhost/Cars/Index], based off of the asp- tag helpers, html tag helpers, and razor syntax.

Below is a diagram I drew in Photoshop displaying the flow of data inside an MVC program.

Troubleshooting in IT. How to quickly gain expertise

Zachary Hadjah — Sun, 31 Jan 2021 15:56:48 +0000

My freshman year I took on an internship with Westfield State University in order to learn more about IT. My supervisor Valerie Depina had informed me that the director, Lynn Zayac, was also a sociology professor. On Top of the IT work, some interns were tasked with making animations to help Lynn give her students visuals, or learning objects, to better understand concepts. Myself and a few other interns had created a few learning objects using Adobe Edge Animate. We would collect sprites off of open source software such as canva.com and use them inside the animations.

Another one of my responsibilities during the internship at the department was trouble shooting. Massachusetts is one of the best states in America when it comes to online learning. UMASS Lowell is known as the best school in America when it comes to online learning. In order to compete, in 2016, Westfield State decided to bolster its efforts in the online learning space. The center for Instructional Technology started to host “Web Camp.” This camp was used as a way to teach professors at Westfield State how to use BlackBoard, Plato, Screen-cast-omatic, office 365, and various other technologies in order to help them teach students online. During Web Camp, the interns served as player coaches because not only did we have to learn the ins and outs of all the different softwares, we also had to help out some of the instructors who were having issues with their systems as we ourselves were learning along with them.

Some of the issues we encountered during webcamp were with synchronization. One professor would try and access some of his word or excel files in order to complete the web camp exercises. When trying to access the files, he noted that some did not appear visible. I asked him If he had saved all of his work onto his tablet and he swore that he did. After restarting his tablet and checking the same file again, I started suspecting that there were synch problems going on in his system. We checked out some of his wifi settings, made sure his One Drive information was up to date, restarted the tablet, and was able to find his files. Other issues also arose later on in Web Camp when Professor’s had to re-subscribe to Office only to have a discrepancy between the Office 365 ID and password. This was an easy fix as you could just reset the password.

After my first semester as an intern, I was hired as a student staff member. Valerie liked the help I gave to the professors so she decided to move animations onto the interns and have me focus on the help desk. My duties for help desk consisted of many tasks like answering help desk tickets during and after school hours, maintaining software updates to all in house devices, ensuring that all devices (laptop,desktop and tablets) were clear of any malware or bloatware, keeping stock of essential equipment, and troubleshooting issues for students and staff members of Westfield State both in person or over the phone. Myself and the other student staff members would rotate our shifts when answering help desk tickets. Often times I would stay on call during night and weekend. These questions would range from students asking to reset passwords to students notifying us that professors had uploaded incorrect documents in which we would have to contact the professor to fix the problem. However, issues would sometimes popup that were beyond my control. In cases like this I would have to reassign the ticket to either the supervisor or the head of the department in order to implement some administrative changes.

Troubleshooting over the phone was one of the harder aspects of moving over to the help desk. I worked as a student staff member for the help desk from 2017 to 2019. This was before the pandemic and before zoom was popular. In order to properly diagnose issues, I would have to carefully communicate with folks who would sometimes have a hard time navigating their operating system. I’d open my laptop and walk through each and every single step carefully so that the client never misclicked anything. Constantly keeping up with them by asking questions like “Do you see the plus button to the right of where its asking you for your information? Click that and enter all the necessary information its asking for.” Once, during my junior semester, a few students and I were all taking an Elements of Systems Programming class together. I remember two of them being hardcore gamers and would allocate a significant portion of their RAM to gaming. This would hurt them in the class because when working on in class assignments, their machines would slow to a halt. They did not allocate enough RAM for their Ubuntu systems to run at a fast enough pace to follow the instructions of the professor. They knew I worked for the department, so one of them decided to give me a call. Matt called me first looking to speed up his Ubuntu system since he couldn’t afford to let his grade drop any further. Since I was relatively familiar with Ubuntu at that point, I was able to troubleshoot his problems enough to the point where he ended up allocating enough RAM for his Ubuntu to run at breakneck speeds with the power of his gaming laptop. Matt tried helping Ethan allocate his memory but since he wasn’t experienced communicating, Ethan eventually ended up calling me on the department line. We went through the exact same process.

A few times issues would come in areas where we weren’t prepped for. We had a few students and professors who would come in with bricked iPhones or tablets. We still decided to help them out anyway by searching on reddit forums and watching youtube videos. Eventually we were able to figure out how to boot up the devices and provide excellent customer service while also adding more techniques to our toolbelt.

I’ve gained knowledge quickly about effective troubleshooting methods mostly because of my resourcefulness. If I’m working in an area in which I’ve never encountered before, I pay close attention to fail statements and input those same exact fail statements into Google, Bing, Youtube or post questions to reddit forums or discord servers. The reason why I’m such a fan of forums and online servers is because I like to remain in areas in which the people who I’m associating with are much more competent in the specified field of study than I am. This ensures that the only advice I comes from top tier professionals that I can rely on. It also forces me to retain their knowledge and put it into my own toolkit so I can troubleshoot unfamiliar problems with more ease.

During the pandemic I decided to catch up with a few friends who had gone on to get hired due to their background in IT. One friend specifically mentioned how his company mandates that when new tech has been deployed, every common inquiry from clients requires a knowledge article to be written. A knowledge article is a detailed document about certain problems, how the client most likely ended up at that error, and how to solve the error and keep it from happening. This document usually consists of photos, embedded videos, directions that will need to be typed into certain input fields, and many other visuals that can help guide non-technical clients. One friend had sent me one of their knowledge articles to give me a better idea of the concept. It seemed like such a simple yet smart way of communicating ideas. I’ve used knowledge articles to give simple solutions to errors and to better express my ideas and showcase my expertise in other fields of study. Instead of taking up time between the two parties to set up an appointment and one trying to instruct the other, its a smarter idea to have documentation ready so that the other party can have a way or fixing issues themselves at any time.

How to begin to set up Data Services file for a Web Application's Database

Zachary Hadjah — Sun, 31 Jan 2021 13:21:17 +0000

Between Identity Framework, authentication, authorization, and data services, the .net environment allows developers to build applications with security at the forefront. Seeding Data into a database is essential for developers to test programs. When in development, you can test this seed data without having to depend on your client’s information to test. You can also seed certain types of data into programs such as administrator accounts, moderator accounts, and accounts for other developers who will be working on the program. This sort of information you would want to isolate for two reasons. First, you wouldn’t want to seed data inside the Program.cs file because this would violate the single responsibility principle. The Program.cs should not have the responsibility of seeding data and calling the startup.cs file. The single responsibility principle is strictly enforced to make programs reusable and to simplify error handling. Second, If someone were to be able to access the program using nefarious techniques, sensitive information can be decrypted and stolen. In order to solve both problems, a developer will need to create an entirely separate file for Services. Next, the developer will need to pass an instance of IHost to the DataService.cs.

The Service file will feature a DataServices file whose single responsibility will be to seed data for the program. The instance of IHost will allow different objects of the program to obtain their specific services. The specific services are instantiated implicitly since it is easier for it to take on the form that it’ll be assigned to. Lastly, the variables with their specified services will be passed as parameters into the private asynchronous methods.

This method of data managment is known as a wrapper method, or in design terms, the adapter pattern. This pattern allows two interfaces, both with separate responsibilities, to interact with each other. The first interface (the client) will call another interface (the adaptee) in order to complete a service such as providing data, or instantiating a certain number of objects via its private static classes. This method of seeding an administrator and a moderator inside an adaptee is a top tier security technique. If need be, this design pattern can also be used for other services in order to instantiate more objects via multiple incompatible interfaces.

This is just the skeleton of the implementation. As the cohort goes along, our cohort will properly configure interfaces and properly implement dependency injection.

Debugging PostgreSQL while working with ASP.NET Core MVC applications

Zachary Hadjah — Sun, 31 Jan 2021 06:54:26 +0000

For our cohort, our instructors decided to use PostgreSQL to maintain the objects in the backend. PostgreSQL allows us to implement CICD principles by deploying the project to Heroku for free. Our CarPro project had us create a Parent table of type Lot and a child table of type Car. The website would display all the cars that the lot had for inventory. Our instructor Jason had a lot of experience troubleshooting PostgreSQL. Though I myself had issues, I decided to head to the breakout room and pay attention to what Jason was doing to help students troubleshoot their problems related to postgreSQL.

I exited the main zoom meeting and joined the breakout room that Jason and a few other students had started and decided to listen in on him trouble shooting with students. The very first problem most folks had was with their passwords, of course. Standard IT problems that will never go away. As someone that has 15 years of experience in the industry, He knew exactly how to fix it. Uninstall, then reinstall, and write down the password this time. Other problems occurred when it came to older versions of nuget packages being installed instead of the latest version.

The first set of complicated cases came when students were trying to use pgAdmin with their mvc applications but unknowingly had too many instances of pgAdmin downloaded. Students would try and work with the package manager console only to have their builds fail. Jason’s method of troubleshooting seemed very logical. He saw that the nuget package manager had installed npgsql. He then checked all the files inside the solution explorer that pertained to setting up pgAdmin. No problems were found inside any of the files. This was what led him to check all the installed programs on students laptop. Once you pull up the Apps & Features option you will be able to see how many versions of the software the student has installed. Some students had too many versions of postgreSQL installed onto the computer. This caused conflicts because EntityFrameworkCore didn’t know exactly which one to interact with, which was why there were so many build errors.

Windows Key> Type: installed > Apps & Features > Type: postgresql

One of the harder to spot problems when it came to troubleshooting postgreSQL issues was with the connection strings. Under no circumstance will an application run as intended if the connection string is not properly written. Below is my connection string for the Car Pro project.

From Server all the way down to Password, all the parameters are correct. However, when I was inside listening in on Jason troubleshoot with some of the other students, I had heard him give students some insight into how pgAdmin configures connections strings. Multiple students had issues working with the package manager because they had conflicting port numbers. The default port connection that PostgreSQL uses is 5432. Students had all sorts of numbers in their ports. To fix the port number issues, me and a few other students found answers on stack overflow as to how to find the correct port number, or how to change it. Had I not stayed in that breakout room, I wouldn’t have had that piece of knowledge.

As written in a few of my other articles, I’ve become a lot better at the art of asking Questions to developers. When troubleshooting with senior developer that have years of experience on you, always analyze their language. When troubleshooting out loud amongst each other, seniors will often times think out loud aswell. Keep their words at the back of your mind so that if the problem is fixed, you can ask them about their thought process later on. Also, analyze their toolkits and the software they use in order to help them troubleshoot. Instead of just waiting my turn in order to get any issues I had fixed, I paid close attention to Jason’s thought process when talking to other students. I also asked him about how he was able to come up with certain solutions.

He told me that I should always try to focus on the problem, and then isolate it completely. After that, think of how the broken mechanism gets triggered/activated. To properly do this, reading documentation is key. If you have seen that the files inside the solution explorer are all properly configured, but when _context is called to store data into the Database and the program crashes, you can then infer that either the problem lies in how the database was called, or that the database was never called in the first place. At this point, you’d go back into the appropriate files in the solution explorer and check. After checking and seeing that the DB was called correctly, you infer that the software for the DB hasn’t been called. This leads the developer to bring up the installed programs. This is where you would be able to tell that pgAdmin has been downloaded multiple times. With multiple versions, the program doesn’t know which to use, which is why the package manager is giving error messages. More on how to extract info from senior developers will be coming in other articles.

How to understand pseudocode

Zachary Hadjah — Sun, 31 Jan 2021 04:08:04 +0000

Back in freshman year during undergrad, I remember being in my professor's office hours asking for help with an algorithm. I still don't remember what the algorithm was, but what I recall was how I didn't understand how I was supposed to properly format and code the algorithm. All of this was preparation for an exam. I asked him how I was supposed to do all of this during a test in which I would have to write it by hand. His response sticks with me to this day, "Never memorize anything. Understand how tools work, understand the order of operations, and go from there."

Pseudocode is a great way of using English in order to understand code.

      Alloc mem for int userInput;
      If(userInput > 5){
        OUTPUT("Larger than 5");
      }

The above line of pseudocode would never compile on any ide in any language, but would be easy for humans to simply understand.

Allocate memory for an integer variable.
-If that integer variable is larger than 5
-Print to the console

In terms of pseudocode "syntax," there really isn't any method of writing it properly. It's mostly just minimal language that allows the programmer to understand exactly how to format the code:
-What order each operation needs to be placed in
-Where loops or logic statements need to be placed
-How to structure algorithms
-Where to place variables for certain formulas

Recently I created a mini-site in which I implemented pseudocode in order to help me better construct the logic behind the classic FizzBuzz problem. The version of FizzBuzz I completed takes two numbers below 100 as input. It will print fizz for all the numbers that are divisible by the first number, and buzz for all the numbers that are divisible by the second. It will print FizzBuzz for all numbers divisible by both numbers.

//loop over every number between 1 and 100
For(variable being accessed){

//print fizzbuzz if the number is divisible by both user inputs
If((varElement % fizzNum)== 0 AND (varElement % buzzNum)== 0)
OUTPUT("FizzBuzz")

//print the number if the number isn't divisible by both user
//inputs
If((varElement % fizzNum)!= 0 AND (varElement % buzzNum)!= 0)
OUTPUT( var )

//print fizz if the number is divisible
If((var % fizzNum)==0)
OUTPUT("Fizz")

//print buzz if the number is divisible by the buzz number
If(((var % buzzNum)== 0)
OUTPUT("Buzz")
}

Of course, you would have to have an understanding of the mod operator and equality operator to understand the code above, but the pseudocode mixed with the comments are enough to get a basic understanding of the algorithm.

Understand the tools you have to work with, the problem needed to be solved, then use pseudocode to format the algorithm.

Why CICD Is so Important

Zachary Hadjah — Sun, 31 Jan 2021 02:31:59 +0000

You just got hired to work for a top tier tech company in Silicon Valley. You're making an annual salary of $90,000. You just started your first week. Your company dishes out roughly $1875 per week for your salary. You create a branch off of the company's main branch that your team is working on in order to implement your user story. You’ve implemented 70% of the user story after ten days of work but all of your work is only accessible in your local repository. You end up losing your hard drive without pushing anything to the Github repository.

$1875 / 5 days a week = $375 per day
10 days of the sprint * $375 per day = $3750

Unless you've memorized each and every single line of code you've written, you’ve just cost your employer $3750! This is one of the many reasons why constantly committing and pushing code that is functional to Github is essential. In order for juniors to get into this habit from an early stage in their career, senior engineers should require that their new employees download the github extensions into there IDE’s before getting on site or even logging into their first Zoom call if all extensions are not already available. Not all juniors are comfortable with the terminal’s GUI or git commands, so this will make it easier for them to adapt to the process. Next, before allowing junior developers to even listen in on a pair programming session, senior engineers should explain the github workflow. The importance of branching, how and when to merge, and how to avoid conflicts. Seniors should let developers know that once a crucial piece of functionality is implemented, a push should follow immediately. Pushes should also be made right before a developer makes the decision to implement something they are not entirely familiar with, such as a new library or new algorithm. This way, when they run into bugs, its not a game-changer if they end up creating more headaches than solutions.

Once user stories have been completed, sprints have been wrapped up, and the site has undergone all the QA testing, deploying the site would be the next big step. Sites such as Netlify use Github’s API in order to connect to repositories the company has and deploys them to the cloud. Netlify is a nice open-source tool in order to host and maintain front-end websites. However, Depending on the company size and budget, the company can also make use of Azure or Heroku in order to host full-stack applications that feature complex backend architecture and Database management. The principles learned from CICD practices and Github source control are one of the primary reasons why the Tech industry has been able to hold the line during this pandemic. Juniors unfamiliar with these concepts should take notice early in order to avoid conflicts in the future.

The 5 Concepts Every Programmer Must Understand

Zachary Hadjah — Sun, 31 Jan 2021 02:15:40 +0000

Back in freshman year, My professor wrote down five things onto the whiteboard and told us that we needed to understand these concepts. These were the fundamentals of computer programming. No matter which language you learn first, or decide to migrate to, you will be able to solve any programming problem by simply implementing these fundamentals.

-Take input
-Allocate memory
-Give output
-Make decisions
-Loop

Take input is often the first fundamental taught when teaching students. This could be something as simple as creating a console application and prompting the user for a number as input. Many languages have different ways of taking input. With Java, you can use System.in.read() (don't forget to flush the keyboard buffer) or the scanner class. In C#, when dealing with console applications, you'll most likely start out using console.ReadLine(). Different methods, same concept.

Allocating memory is usually the next step when it comes to taking user input. After a user enters input, depending on the type of input it is, the program may need that user's input in order to process it later on. For starters, the user input will most likely be stored into a primitive type such as an integer. Later, user input can be stored into objects such as strings. Once programmers become more advanced, they can then start to allocate user input into more complex data structures such as Trees or Lists.

Giving output is simply displaying information to the user that is easily digestible. Maybe you are building a calculator application and need to display the results. Maybe you've created a complex algorithm for your fortune 500 employer and need to display the results into a data table so non-technical folks can easily digest it.

In programming, there are a lot of decisions needed to be made by the developer. When a developer wants the program to make a decision, they will need to incorporate if-else statements that will allow the proper decision to be made. Senior developers tend to use ternary operators and nested complex statements that tend to obscure the logic for the juniors, but that's what comments are for. At the end of the day, fundamentally, these statements come down to basic if-else statements.

Looping is one of the most essential concepts juniors should familiarize themselves with. Need to access data of an array? For loop. Need to create a chessboard? Two for loops. Need simple input validation?

             While( input != null ){
             }

Looping can be simply taught, however, when complex problems start to arise, that's when certain loops become harder for juniors to understand. Don't fret, in order to run you must crawl. If you can understand how a for loop allows the program to access all elements inside an array, you'll be able to understand how a foreach loop can allow the program to access all items inside a Model inside an MVC application.

In Coder Foundry, we were tasked with creating minisites that will allow us to complete coding challenges and display results to the user. In order to complete the FizzBuzz mini-site, I needed to revert back to the 5 concepts. The program will take two inputs from the user and allocate them as integer data. Next, loop through all numbers between 1 and 100. Print "Fizz" if the first user input is divisible by the number that is currently in the iteration, or "Buzz" if the second number is divisible by the number inside the iteration. Otherwise, just print the number itself.

Making decisions is usually the hardest part for students to understand because it involves algorithmic thinking. The FizzBuzz application makes decisions based on the else if statements.

Lastly comes Giving output. The programmer will need to give output in a way that is easily digestible for other programmers and non-technical clients viewing the program. For this specific project, I created a table class in markup, and then manipulated the data (Making Decision and looping) in order to display the results properly to users.

From personal experience, I've gone from Java, to C++, to C, and now C#. Syntax differences will sometimes get in the way of things, however, strong programming fundamentals will always allow developers to keep a level head and understand complex problems by analyzing which of the 5 concepts need to be implemented and at what point in the program.

Click the link to view the project:
https://zacharyhadjahfizzbuzz.netlify.app

Getting started with .NET

Zachary Hadjah — Sun, 31 Jan 2021 02:10:28 +0000

Originally Written in June

Since the pandemic hit, I’ve seen many recruiters writing articles about how the job market has become the most competitive they’ve seen in years. I started out developing in Java, but since most of the job applications I filed out in Massachusetts required candidates to have .net experience, I decided to learn more about it. In order to hone my skills and stand out to employers and recruiters, I’ve done extensive research and preparation in order to educate myself on Microsoft’s Tech Stack ( .NET, ASP.NET Core, ASP.NET MVC, SQLServer, EntityFramework Core, Identity Framework, and Azure). This allowed me to adapt to C# very easily since both languages are similar to each other when it comes to programming fundamentals.

Microsoft originally created C# in order to implement features they felt were necessary as well as fix some of the issues they had seen in other languages. Where the differences started to become clear was in the documentation, implementation, and support for both languages. Even with updated documentation and new versions coming out, Oracle does not go out of its way to educate its customer base the same way Microsoft does. Microsoft’s social media presence, forums for developers, and informative personalities such as Scott Hanselman and Bob Tabor are what allow developers like me to be kept up to date with some of the new material and documentation the company offers.

I'm a firm believer that one can only learn by doing. I’ve used Pluralsight and Udemy courses in order to help me undergo some project-based learning. I’m currently building a Help Desk Ticket web application, built-in ASP.NET Core MVC. The application will function as a way for employees of a company to submit tickets in order to help with technical problems. IT professionals, who will serve as admins of the app, will be able to administer tickets accordingly.

I first laid out a sprint and UML Diagram in order to map out the project. I then worked closely with a mentor from Codementor, a website that pairs programmers with experts in order to help solve programming problems, to consult with. He then informed me of Microsoft’s Identity Framework. This authentication system Microsoft has created allows programmers to easily build applications in which users can sign in and create their own “identities”, or accounts. For example, in terms of the login process, that is all handled on the backend using C# code generated by various standard authentication protocols written by Microsoft. I worked with my mentor closely so that he could help me understand the functions that the identity authentication generated. After adding authentication into the configure function, we then discussed the best way to override the Login.cs and Register.cs files so that it can fit the application. I wanted the user’s email to serve as the username, so I had to customize both the Register.cs and Login.cs file.

Since I’m still learning Full stack development, I didn’t want to reinvent the wheel when it came to the frontend. After discussing with other developers on Microsoft’s C# discord chat, in order to make the web app visually stand out, I decided to use a bootstrap template. The template I chose will allow me to add simple HMTL forms, notifications, and stunning background images to make the app look modern, especially when I have completed the login, register, and forgot password page. As of right now, I am currently in the process of getting a Database set up in order to store data pertaining to the application.

While working on the project, I realized that a lot of in-person coding boot camps have switched to online learning. I decided to apply to Coder Foundry, a boot camp out of North Carolina. I believe this will allow me to become entirely competent in Microsoft's tech stack since Coder Foundry has a proven track record of placing their graduates into employment with top tech companies upon graduation. Their barrier to entry, student portfolios, and recruitment program has earned them an 85% success rate amongst students. I’ve been following the company’s Youtube channel since the pandemic started and their student’s results are impressive. The Bootcamp starts January 4th and from the diagnostic tests and phone calls I’ve had with their employees, they seem to be indicating that I would fit nicely into their program!

For peers, recruiters, or hiring managers that have come across this article, I will be posting more articles about my experiences with Full-Stack development and the .NET Framework so please look forward to more!