DevBook

Bootstrap is a popular CSS framework that allows developers to build responsive, mobile-first websites easier and faster. Interestingly enough, Bootstrap began as an internal tool used at X (formerly Twitter) to maintain a consistent look across their platform. In 2011 it became open-source and now it is one of the most widely used CSS frameworks in the world. Here is why Bootstrap is so great..

1. Responsive by Default: Bootstrap automatically adapts to different screen sizes, ensuring consistent viewing experiences across different sized devices.

2. Flexible Grid System: Bootstrap provides a 12-column grid system that allows you to create responsive layouts effortlessly. You can arrange content in rows and columns, adjusting their widths based on the device's screen size.

3. Prebuilt Components - Bootstrap offers pre-designed components like navigation bars, buttons, modals, and carousels. This can save a lot of time and effort creating custom components from scratch. These components are also easily customizable to fit your project's needs.

Let's see Bootstrap in action! We will create a responsive navigation bar. 

I will add this code snippet from the Bootstrap navbar docs to the HTML body.

Notice the use of the different classes in many of the HTML elements. These classes are what allows Bootstrap's built -in, responsive CSS to take effect on the HTML. And just like that, we have a fully responsive navigation bar that collapses to a drop-down on smaller screens.

Fullscreen:

Mobile:

Bootstrap is simple to learn and with some practice it can become a great tool for increasing speed and efficiency when creating responsive user interfaces. To learn more about Bootstrap and how you can get started using it visit the website and checkout the docs at https://getbootstrap.com.

Becoming a successful self-taught software developer is a journey that requires dedication, resourcefulness, resilience and strategic planning. The challenges can seem overwhelming at times especially when the competition in the market is tough. Here’s a condensed guide to help you navigate this rewarding path from someone who is currently on this path as well.

1. Know Your Why

A growth mindset and knowing your WHY is essential for overcoming challenges and continuously improving. Embrace failures as learning opportunities and stay committed regardless of setbacks. You only fail if you quit. Having a strong WHY will keep you in the game when the going gets tough. 

Tips:

• Set Clear Goals: Define short-term and long-term learning objectives.
• Celebrate Progress: Acknowledge your achievements and seek feedback to refine your skills.
• Remember: Frequently remind yourself of why you are on this journey to begin with.

2. Build a Strong Foundation

Mastering core programming concepts is crucial. Focus on:

• Programming Languages: Gain proficiency in key languages like JavaScript and C#.
• Data Structures & Algorithms: Understand fundamental concepts and problem-solving techniques.
• Version Control: Learn to use Git for managing code and collaborating with others.

Resources:

• Online Courses: Explore platforms like Udemy or Coursera.
• Books: Read foundational texts like "Clean Code" by Robert C. Martin. This is a classic book on programming best practices. I have read it myself and it is excellent.

3. Work on Real Projects

Practical experience is vital. Build projects to apply what you’ve learned and demonstrate your skills.

Project Ideas:

• Personal Projects: Create apps or tools that interest you.
• Open Source: Contribute to projects to gain experience and visibility.
• Freelancing: Take on freelance work to build your portfolio.

Tips:

• Start Small: Begin with manageable projects and scale up.
• Document Your Work: Use a GitHub repository or personal website to showcase your projects.

4. Network and Build a Personal Brand

Networking and personal branding are key to career growth or breaking into the industry for the first time. Connect with other developers and showcase your skills.

Networking Tips:

• Attend Meetups: Join local or online tech events.
• Leverage Social Media: Share your projects and insights on LinkedIn or Twitter.

Personal Branding:

• Create a Portfolio: Develop a website or GitHub profile to highlight your work.
• Write Blogs: Share your experiences and knowledge through blog posts like this one.

5. Consistency Is Key

Effective time management and consistent practice is essential for balancing learning, projects, and other responsibilities.

Tips:

• Set a Schedule: Allocate specific times for learning and coding. Even a little bit each day goes a long way over time. (Read The Compount Effect by Darren Hardy)
• Use Productivity Tools: Tools like Trello or Asana can help you stay on track.
• Avoid Burnout: Ensure a healthy work-life balance by taking breaks and not overdoing it.

6. Seek Mentorship and Prepare for Interviews

Mentorship provides valuable guidance, and interview preparation helps you showcase your skills effectively.

Finding a Mentor:

• Join Mentorship Programs: Look for networks or programs connecting mentors and mentees.
• Reach Out: Contact experienced professionals for advice.

Interview Preparation:

• Practice Technical Questions: Prepare for coding and problem-solving interviews.
• Mock Interviews: Conduct mock interviews to build confidence and receive feedback.

Conclusion

Success as a self-taught software developer requires commitment, practical experience, and continuous learning. By focusing on core skills, working on real projects, networking, and seeking mentorship, you can build a solid foundation for a successful career. Embrace the challenges, stay motivated, and keep pushing forward. Your dedication and drive will turn your self-taught journey into a great professional achievement.

When working as a programmer with Microsoft tools and technologies there are many options to choose from. Two very popular frameworks for web development offered by Microsoft are ASP.NET Core and ASP.NET. While both frameworks are used for building robust web applications, there are a few key differences between the two and it's important to know the differences and how each framework can best be utillized. 

ASP.NET

ASP.NET was first released by Microsoft in January 2002 and stands for Active Server Pages Network Enabled Technologies. It is a mature framework and is designed for building enterprise-grade, server-based web applications. It operaties exclusively on the Windows platform and is built on the .NET Framework. A few key features of ASP.NET include:

Web Forms: A drag-and-drop, event-driven model for building web applications.

MVC (Model-View-Controller): A pattern-based way to build dynamic websites.

Web API: For building RESTful services.

Web Pages: Combines HTML, CSS, and server-side code using Razor syntax.

ASP.NET has been a reliable choice for many years, especially for Windows-centric applications. However, it has some limitations, particularly in terms of cross-platform support and modern development practices. This is where ASP.NET Core comes in.

ASP.NET Core

ASP.NET Core was released in 2016 and is a complete redesign of ASP.NET, focused on addressing the limitations of ASP.NET. It is an open-source, cross-platform framework that can run on Windows, macOS, and Linux. Here are some of the key features of ASP.NET Core:

Cross-Platform: Unlike ASP.NET, ASP.NET Core can run on multiple operating systems, making it a versatile choice for diverse development environments.

High Performance: ASP.NET Core is optimized for performance, offering faster execution times and lower memory consumption compared to it's predecessor.

Unified Framework: It combines the capabilities of MVC and Web API into a single framework, simplifying the development process.

Modular and Lightweight: ASP.NET Core allows developers to include only the necessary components, resulting in a more lightweight application.

Built-In Dependency Injection: This promotes better code maintainability and testability.

Cloud-Friendly: ASP.NET Core is designed with cloud deployment in mind and offers seamless integration with modern cloud services.

Why choose ASP.NET Core?

Given the advancements and features of ASP.NET Core, it is often the preferred choice for modern web development and unless a developer is working with a legacy, enterprise web application it is best suited for most development projects today. Here are a few reasons why:

Flexibility and Scalability: ASP.NET Core’s cross-platform nature allows developers to build and deploy applications on various operating systems, providing greater flexibility. Its modular architecture also ensures that applications can scale efficiently.

Performance: The high-performance capabilities of ASP.NET Core make it suitable for building high-traffic web applications. It's lightweight nature ensures faster load times and better resource management.

Modern Development Practices: ASP.NET Core embraces modern development practices such as dependency injection, asynchronous programming, and a unified development model which combines MVC and Web API. This results in cleaner, more maintainable code.

Community and Support: Being open-source, ASP.NET Core benefits from a vibrant community that contributes to its continuous improvement. Developers can access a wealth of resources, libraries, and tools to enhance their development experience.

Future-Proof: ASP.NET Core is the future of Microsoft’s web development framework. With regular updates and new features, it ensures that developers are always equipped with the latest tools and technologies.

Conclusion

While ASP.NET remains a solid choice for Windows-based, legacy applications, ASP.NET Core offers a more modern, flexible, and high-performance framework suitable for today’s web development needs. Its cross-platform capabilities, improved performance, and alignment with modern development practices make it the right choice for developers looking to build scalable and maintainable web applications. 

When searching data structures for specific values there are multiple methods that can be used to find a desired value. Two popular  methods are a linear search and a binary search. A linear search works by checking each item in a list or array one at a time to see if it matches the target value. This search method is best suited for unsorted data.

For example if you are given a 100 page book where all the pages are out of order and you were told to find page 45 you would use a linear search by checking each page one at a time until you find page 45. This could potentially take 100 page turns if page 45 happens to be at the end of the book of shuffled pages. With unsorted data this is necessary because each item could be in any location. However, if the data is sorted a linear search might not be the best approach. Enter binary search. 

If you are given the same 100 page book with the book pages in order as they usually are and you are told to find page 45 you would have to turn 45 pages to get to the correct page if using a linear search. In this same scenario a binary search would only have to turn 7 pages because each turn is eliminating half of the book.

When working with a sorted data structure a binary search is a much more efficient algorithm to find a specific value. Instead of starting at the beginning and looking at each item one by one a binary search works by repeatedly dividing in half the portion of the data that could contain the target value until you've narrowed down the possible location to one. Here is a step by step breakdown of a binary search followed by an example of the algorithm written in C#.

Steps to implement binary search

1. Start with a list of sorted data
2. Find the middle elment in the list
3. Compare the middle element to the target value
4. If the middle element is equal to the target value the search is complete
5. If the middle element is less than the target value repeat the search on the right side of the list
6. If the middle element is greater than the target value repeat the search on the left side  of the list
7. Continue this process until the target value is found or until there is no more data to search

The Code

In conclusion, binary search is a powerful algorithm for searching in sorted data structures. Due to it's speed it is a preferred choice for large sorted datasets. Understanding and implementing binary search in C# can signifigantly improve the performance of your application's search operations.

When programming the term dependency comes up quite frequently. All a dependency is is an object that another object relies upon to get it's job done. Dependency Injection (DI) is a design pattern used to implement Inversion of Control between classes and their dependencies. Inversion of Control simply means that the control of object creation and management is transferred from the programmer and the application code to a container or framework. This process allows for better modularity, testability and maintainability of code. ASP.NET Core provides a built-in container for handling dependency injection which was added in 2016. This makes it easier to handle dependencies in applications.

How to use Dependency Injection?

Dependency injection is performed by following these steps.

1. Create an interface which will be the contract for the dependency
2. Create a class that implements this interface
3. Register the service in the DI container. (In ASP.NET Core this will be in the Program.cs file)
4. Inject the service into the class that needs it via constructor, method, or property. (Constructor is the most common)

Implementing Dependency Injection

We will start with a model class taken from an ASP.NET Core MVC project. This model represents book categories.

The first thing we need to do is create an interface which is going to serve as the contract for our dependency. We will use the Repository Pattern for this interface. The Repository Pattern provides a layer of abstraction over data access, allowing for cleaner separation of concerns. When combined with Dependency Injection it enhances modularity and testability. 

Here ICategoryRepository implements IRepository and passes in a Category. It also has an Update method that will be used to update categories. Next we will create the class that implements this interface.

Here, the CategoryRepository class implements the ICategoryRepository interface and fulfills it's contract by providing a definition for the Update method.

Third we need to register the service in the DI Container which in ASP.NET Core is the Program.cs file.

The service lifetime is something that will not be covered in this article but in short there are 3 options for service lifetime, Transient, Scoped and Singleton. Here we are using scoped which lasts the duration of an HTTP request.

The last thing to do is to inject the service into the class that needs it. This will allow us to use the dependency in our code to update Categories.

We have "Injected" the ICategoryRepository into our CategoryController class so we are now able to use the dependency to update categories by calling _categoryRepo.Update(obj); and passing in a Category object.

Conclusion

In conslusion, Dependency Injection is a powerful pattern that enhances the modularity, testability, and maintainability of ASP.NET Core applications. By leveraging the built-in DI container, you can easily manage your application’s dependencies and lifetimes, leading to cleaner and more maintainable code.

I hope this article helps you understand Dependency Injection in ASP.NET Core! If you need further clarification check out the docs at https://learn.microsoft.com/en-us/aspnet/core/fundamentals/dependency-injection?view=aspnetcore-8.0.

As most people know, sales can be an extremely rewarding career path. The ceiling is high, the floor is low, and it often requires thick skin. Having spent several years in management and customer service I eventually transitioned into full-time sales in 2017 and followed this path for 6 years before realizing a passion for software development. It was at that time I decided to initiate a career change. Here is why I decided to leave my sales career behind to pursue a career in tech.

For awhile I had been getting the "itch" to do something new. I wanted to take my career in a different direction but I just wasn't sure which direction I wanted to go in. Sales requires a certain personality type to stick with long-term and while it was something I was good at, it wasn't something I saw myself doing for years to come. I started looking at other options to see what my choices were.

Discovering Web Development

One day I was driving and listening to a podcast on careers when the host mentioned the market's need for web developers with people skills. I thought "I don't know anything about web development but my people skills are alright I suppose..". So I spent a few days researching the requirements and dove in head first. I bought a personal laptop (all I had up until this point was a work computer), and began a full-stack web development course on Udemy learning the fundamentals like HTML, CSS and JavaScript.

Programming presented a new challenge, a challenge worth conquering. The potential growth and flexibility in software development also excited me. I have never considered myself to be a tech guru. Outside of using necessary work applications and sending emails I never had a need to learn much about technology, software development, or the way my devices actually worked. I've always loved interacting with people and people were never in short supply when working in customer service or sales but I wanted a different kind of challenge and coding gave it to me. While sales is challenging it is very different from programming. Programming requires complex problem solving and forces the programmer to use a different set of skills outside of the people skills required to be a good salesman. I was in for the long haul and loved the feeling of learning a new set of skills and taking on an endeavor that I considered to be very difficult.

Another reason I wanted to become a programmer is it seemed like a better fit for my personality. While I love interacting with customers, and have no issues in social situations, I am more introverted than extroverted. I liked the idea of being able to get in the zone and work on a task without the need to constantly be exerting social energy. This allows me to interact with customers and talk with teammates when needed while also being able to recharge while working on development oriented tasks.

Landing My First Job In Tech

After a year and a half of working sales and coding on the side I was able to land a  full-time role on a development team working production support and quality assurance automation. Over the past year I have had the opportunity to work with Selenium, C#, ASP.NET Core, Playwright, SQL and various other technologies and am very thankful for this opportunity to continue to grow and learn. I have still been learning consistently on my own time as well and working toward my ultimate goal of becoming a software developer. I am very happy with my decision to pursue software development and am looking forward to continuing the journey.

Happy coding!

Object-Oriented Programming, commonly referred to as OOP, is a programming model that uses 'objects' to design and build applications. It simplifies software development and allows for scaling large applications because of it's time-tested pillars. These pillars are objects, classes, inheritance, polymorphism, encapsulation, and abstraction.

Pillars

1. Classes and Objects• Class: A blueprint for creating objects. It defines the datatype, properties, and methods by bundling data and the methods that work on that data in a single unit.• Object: An instance of a class. It is self-contained and when created it contains the methods and data needed to make the class useful in a programming scenario.
   
   
2. Inheritance
   • Inheritance allows a class to inherit properties and methods from another class. This ensures code reusability and helps keep the code DRY (Don't Repeat Yourself).
   
   
3. Polymorphism
   • Polymorphism means "the ability of something to have or to be displayed in more than one form". In OOP this allows methods to do different things based on the object it is acting upon. This can be done through method overriding and method overloading. Here is an article that goes more indepth into polymorphism. 
   
   
4. Encapsulation
   • Encapsulation is the concept of wrapping data and the methods that operate on that data within one unit (a class for example). It promotes clean programming and allows the developer to control when and how data can be modified.
   
   
5. Abstraction
   • Abstraction is the concept of hiding the complex implementation details of an object and only showing its necessary features. This helps reduce programming complexity and effort as a developer doesn't need to know everything about the internal components of a class to use its methods.

Benefits of OOP

• Modularity: The source code for an object can be written and maintained independently of the source code for other objects. This helps ensure clean code and separation of concerns between objects.

• Reusability: Objects can be reused across the program to cut down on repeated or unnecessary code.

• Ease of use and debugging: It makes fixing bugs easier because if a certain object becomes problematic it can be removed and replaced with a different or more finely tuned object. 

Conclusion

Object-Oriented Programming is a powerful programming style that helps organize complex software systems and large applications. By understanding and implementing the principles of OOP, developers can create more reusable, maintainable, and robust code.

Thanks for reading!

When working with GIT it is usually pretty simple when there aren't other people involved. You commit your changes as you go and push to the remote repository as needed with little concern for merge conflicts. 

When working with a team on a large application there are tickets being assigned, changes being made by different people and if there is not a strategy in place to avoid unnecessary headaches you might spend part of your day fixing merge conflicts instead of submitting a PR and moving on to the next priorty ticket.

There are different strategies that developers can use to ensure a smooth PR process and this is the strategy that has worked will for me. When working with an IDE like Visual Studio the GIT integration makes this process easy but to make the steps apply more universally I'll use the command line in this post.

1. Clone the main (master) repo to local. In your development environment or from a command line window run the command 'git clone <repository url>'. The URL can be retrieved from GitHub by finding the repo you wish to clone, click the Code dropdown and copy the provided URL to the clipboard. This command will save the repo to your local files. If you already have main cloned to local you can run 'git fetch' from command and this will fetch any changes that have been made since your last pull. After viewing the incoming changes run 'git pull' to integrate those changes into your local repo. In either scenario you should now have local main up to date and ready to work with.

2.  Now it's time to create your working branch. With a fresh version of main you can create a new working branch by running 'git checkout -b <working branch name>'. This will create a new branch and check into it at the same time.

3. Make the necessary code changes.

4. After making the changes or implementing the feature you're ready to PR into remote main. This is where things can get hairy. After finishing my changes the first thing I'll do is make sure all changes are committed on the working branch with 'git commit -m <brief summary of  commit>'. 

5. Next checkout main by running 'git checkout main'. This will take you back to local main where you will make sure you are up to date with any changes that have ocurred since your last pull. Run 'git fetch' to see what other changes have been made to the remote main and then 'git pull' to integrate those changes into local.

6. Now that you are completely up to date navigate back to your working branch by running 'git checkout <working branch name>'. When you are in your working branch run 'git merge main' to merge any new changes from main into your working branch. This is where there could be merge conflicts but it's okay because this approach give you the chance to solve these conflicts locally before pushing the PR. I won't go into resolving merge conflicts for now so assuming the merge was successful you have now merged all remote changes into your local and are ready to push the PR knowing that you won't be introducing merge conflicts or errors.

7. Lastly we will commit one last time to ensure any changes brought in from main are commited. After committing run 'git push origin <working branch name>'. This pull push your local branch to remote and you can use whatever ticket management system you work with to finish creating the pull request.

Thank you for reading and happy coding!