<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Rexhep Kqiku (/rdʒep ktʃi:ku:/) on Medium]]></title>
        <description><![CDATA[Stories by Rexhep Kqiku (/rdʒep ktʃi:ku:/) on Medium]]></description>
        <link>https://medium.com/@unhandlederror?source=rss-1c52f9962831------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*NpnJqZWsF_z4nemV.</url>
            <title>Stories by Rexhep Kqiku (/rdʒep ktʃi:ku:/) on Medium</title>
            <link>https://medium.com/@unhandlederror?source=rss-1c52f9962831------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Mon, 16 Nov 2026 14:28:19 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@unhandlederror/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Boosting Productivity by Escaping Uniformity: Insights from ‘Smarter Faster Better’ and ‘Rebel…]]></title>
            <link>https://medium.com/@unhandlederror/boosting-productivity-by-escaping-uniformity-insights-from-smarter-faster-better-and-rebel-145a2c8c966f?source=rss-1c52f9962831------2</link>
            <guid isPermaLink="false">https://medium.com/p/145a2c8c966f</guid>
            <category><![CDATA[team]]></category>
            <category><![CDATA[productivity]]></category>
            <category><![CDATA[books]]></category>
            <dc:creator><![CDATA[Rexhep Kqiku (/rdʒep ktʃi:ku:/)]]></dc:creator>
            <pubDate>Wed, 11 Oct 2023 20:22:38 GMT</pubDate>
            <atom:updated>2023-10-11T20:27:17.064Z</atom:updated>
            <content:encoded><![CDATA[<h2>Boosting Productivity by Escaping Uniformity: Insights from ‘Smarter Faster Better’ and ‘Rebel Ideas’</h2><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*b0jVVgn_Ya7ZMmHah-1AjA@2x.jpeg" /><figcaption>Photo by Priscilla Du Preez 🇨🇦 on Unsplash</figcaption></figure><p>“Smarter Faster Better” by Charles Duhigg and “Rebel Ideas” by Matthew Syed both touch on themes related to improving performance and decision-making, but they approach these topics from different angles.</p><p>“Smarter Faster Better” by Charles Duhigg was a bestseller. The book received widespread attention and positive reviews when it was first published in 2016. It made its way onto bestseller lists and was well-received by readers and critics for its insights into productivity, motivation, and performance improvement.</p><p>“Rebel Ideas” by Matthew Syed was also a bestseller. The book gained popularity for its exploration of diverse thinking and its impact on decision-making and innovation. It received attention and positive reviews, and it found a place on bestseller lists as well.</p><p>“Smarter Faster Better” focuses on productivity and motivation, drawing from case studies and research to provide insights on how to become more efficient and effective. It offers practical advice for individuals and teams to enhance their performance.</p><p>“Rebel Ideas,” on the other hand, delves into the concept of diversity of thought and the importance of diverse perspectives and ideas. It explores how diverse teams and innovative thinking can lead to better decision-making and problem-solving. The book argues that embracing unconventional or “rebel” ideas can be a catalyst for improved outcomes.</p><p>While both books touch on areas related to personal and organizational performance, they have distinct focuses and approaches. “Smarter Faster Better” is more about productivity and motivation, while “Rebel Ideas” is centered on the benefits of diverse thinking. There may be some overlap in general principles, but their primary messages differ.</p><p>Reading “Smarter Faster Better” and “Rebel Ideas” can be a transformative experience, offering valuable insights and perspectives that can enhance various aspects of your personal and professional life. These books provide a unique blend of guidance and inspiration:</p><p>“Smarter Faster Better” is your guide to unlocking productivity and motivation. It offers practical strategies and real-world examples that will empower you to make better decisions, set meaningful goals, and achieve greater efficiency. If you’re looking to boost your productivity and effectiveness, this book is a valuable resource.</p><p>“Rebel Ideas” delves into the power of diverse thinking. In a world that increasingly values innovation and creative problem-solving, this book is a compelling exploration of how embracing diverse perspectives can lead to better decisions and groundbreaking ideas. It challenges the traditional notions of groupthink and highlights the importance of thinking differently.</p><p>These books, each in its own unique way, provide essential tools for personal growth and success. Whether you’re seeking to improve your productivity or harness the strength of diverse thought, “Smarter Faster Better” and “Rebel Ideas” offer the knowledge and inspiration you need to achieve your goals and excel in an ever-evolving world.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=145a2c8c966f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[SOLID Principles: Real-World Examples and Best Practices using C#]]></title>
            <link>https://medium.com/@unhandlederror/mastering-solid-principles-real-world-examples-and-best-practices-298944c083b4?source=rss-1c52f9962831------2</link>
            <guid isPermaLink="false">https://medium.com/p/298944c083b4</guid>
            <category><![CDATA[principles]]></category>
            <category><![CDATA[architecture]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[code]]></category>
            <category><![CDATA[solid]]></category>
            <dc:creator><![CDATA[Rexhep Kqiku (/rdʒep ktʃi:ku:/)]]></dc:creator>
            <pubDate>Sun, 12 Mar 2023 15:18:22 GMT</pubDate>
            <atom:updated>2023-03-19T21:41:50.809Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*IIYr90eHfefuLtsH" /><figcaption>Photo by <a href="https://unsplash.com/@emilep?utm_source=medium&amp;utm_medium=referral">Emile Perron</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>If you’ve ever looked for resources on the SOLID principles, you may have come across examples using shapes, rectangles, and circles that don’t apply to real-world scenarios. While these examples may help understand the principles at a basic level, they may not be as applicable to business applications. As a developer, you may be wondering how to apply these principles to real-life scenarios that you’re likely to encounter. In this blog post, we’ll take a look at the SOLID principles and demonstrate how they can be applied to a real-world example of a notification service. By using a practical scenario, we’ll explore how to implement each principle and show the benefits they can provide in real-world applications. So, if you’re interested in learning how to apply SOLID principles to real-life scenarios, keep reading!</p><p>Solid principles are a set of five object-oriented design principles that have been widely adopted by developers around the world. These principles were introduced by Robert C. Martin, also known as “Uncle Bob”, in his book “Agile Software Development, Principles, Patterns, and Practices” and have since become a cornerstone of good software design. In this article, we’ll explore the Solid principles in the context of a notification service implemented in C#.</p><h3>Single Responsibility Principle (SRP)</h3><p>The first Solid principle is the Single Responsibility Principle (SRP), which states that a class should have only one reason to change. In other words, a class should have only one responsibility. If a class has multiple responsibilities, changes to one responsibility may inadvertently affect the other responsibilities, leading to code that is difficult to understand and maintain.</p><h4>Motivation</h4><p>The motivation behind the SRP is to make sure that each class is focused on doing one thing and doing it well. This makes the code easier to read, understand, and maintain. By adhering to the SRP, developers can make sure that each class is responsible for a single, well-defined task.</p><h4>Symptoms</h4><p>If a class violates the SRP, it may have several symptoms. For example, the class may have too many dependencies, or it may need to be simplified. Additionally, if changes to one responsibility require modifications to other parts of the class, this can lead to a lack of cohesion.</p><pre>public class NotificationService <br>{<br>    public void SendNotification(Notification notification)<br>    {<br>        // Send notification<br>    }<br><br>    public void LogNotification(Notification notification)<br>    {<br>        // Log notification<br>    }<br><br>    public void ValidateNotification(Notification notification)<br>    {<br>        // Validate notification<br>    }<br>}</pre><p>In the code example above, the NotificationService class violates the SRP by having multiple responsibilities. It&#39;s responsible for sending notifications, logging notifications, and validating notifications. This can lead to code that is difficult to maintain, test, and understand.</p><h4>Implementation</h4><p>In the context of a notification service, we can apply the SRP by creating a separate class for each type of notification. For example, we might have an email notification class, an SMS notification class, and a push notification class. Each of these classes would be responsible for sending a specific type of notification, and any changes to that type of notification would only affect the corresponding class.</p><pre>public interface INotificationSender <br>{<br>    void SendNotification(Notification notification);<br>}<br><br>public interface INotificationLogger <br>{<br>    void LogNotification(Notification notification);<br>}<br><br>public interface INotificationValidator <br>{<br>    bool ValidateNotification(Notification notification);<br>}<br><br>public class NotificationService : INotificationSender<br>{<br>    private readonly INotificationLogger _logger;<br>    private readonly INotificationValidator _validator;<br><br>    public NotificationService(INotificationLogger logger, INotificationValidator validator)<br>    {<br>        _logger = logger;<br>        _validator = validator;<br>    }<br><br>    public void SendNotification(Notification notification)<br>    {<br>        if (_validator.ValidateNotification(notification))<br>        {<br>            // Send notification<br>        }<br>        else<br>        {<br>            _logger.LogNotification(notification);<br>        }<br>    }<br>}</pre><p>In the code example above, we&#39;ve implemented the SRP by separating the responsibilities of the NotificationService class into smaller, more specific interfaces. We have an INotificationSender interface for sending notifications, an INotificationLogger interface for logging notifications, and an INotificationValidator interface for validating notifications. The NotificationService class now depends on these interfaces instead of implementing them directly.</p><h3>Open-Closed Principle (OCP)</h3><p>The Open-Closed Principle (OCP) states that a class should be open for extension but closed for modification. In other words, we should be able to extend the behavior of a class without modifying its source code. This makes the code more flexible and easier to maintain.</p><h4>Motivation</h4><p>The motivation behind the OCP is to make sure that changes to a class don’t break existing code. By allowing developers to extend the behavior of a class without modifying its source code, we can make sure that changes to a class’s behavior don’t impact other parts of the system.</p><h4>Symptoms</h4><p>If a class violates the OCP, it may have several symptoms. For example, it may be difficult to extend the class’s behavior, or changes to the class’s behavior may cause other parts of the system to fail.</p><pre>public class NotificationService <br>{<br>    public void SendNotification(Notification notification)<br>    {<br>        if (notification.Type == NotificationType.Email)<br>        {<br>            // Send email notification<br>        }<br>        else if (notification.Type == NotificationType.Sms)<br>        {<br>            // Send SMS notification<br>        }<br>        else if (notification.Type == NotificationType.Push)<br>        {<br>            // Send push notification<br>        }<br>    }<br>}</pre><p>In the code example above, the NotificationService class violates the OCP by not being closed for modification. If we need to add a new type of notification, we&#39;ll need to modify the NotificationService class directly.</p><h4>Implementation</h4><p>In the context of a notification service, we can apply the OCP by creating an abstract base class for sending notifications. Each type of notification (email, SMS, push) would be implemented as a subclass of the base class. If we need to add a new type of notification in the future (e.g., a social media notification), we can simply create a new subclass without modifying the existing classes.</p><pre>public interface INotificationSender <br>{<br>    bool CanSend(Notification notification);<br>    void SendNotification(Notification notification);<br>}<br><br>public class EmailNotificationSender : INotificationSender<br>{<br>    public bool CanSend(Notification notification)<br>    {<br>        return notification.Type == NotificationType.Email;<br>    }<br><br>    public void SendNotification(Notification notification)<br>    {<br>        // Send email notification<br>    }<br>}<br><br>public class SmsNotificationSender : INotificationSender<br>{<br>    public bool CanSend(Notification notification)<br>    {<br>        return notification.Type == NotificationType.Sms;<br>    }<br><br>    public void SendNotification(Notification notification)<br>    {<br>        // Send SMS notification<br>    }<br>}<br><br>public class PushNotificationSender : INotificationSender<br>{<br>    public bool CanSend(Notification notification)<br>    {<br>        return notification.Type == NotificationType.Push;<br>    }<br><br>    public void SendNotification(Notification notification)<br>    {<br>        // Send push notification<br>    }<br>}<br><br>public class NotificationService <br>{<br>    private readonly List&lt;INotificationSender&gt; _senders;<br><br>    public NotificationService(List&lt;INotificationSender&gt; senders)<br>    {<br>      _senders = senders;<br>    }<br><br>    public void SendNotification(Notification notification)<br>    {<br>        foreach (var sender in _senders)<br>        {<br>            if (sender.CanSend(notification))<br>            {<br>                sender.SendNotification(notification);<br>            }<br>        }<br>    }<br>}</pre><p>In the code example above, we’ve implemented the OCP by creating an INotificationSender interface for sending notifications. We have multiple implementations of this interface, one for each type of notification. The NotificationServiceclass is open for an extension because we can add new implementations of the INotificationSenderinterface without modifying the NotificationService class directly.</p><h3>Liskov Substitution Principle (LSP)</h3><p>The Liskov Substitution Principle (LSP) states that subtypes should be substitutable for their base types. In other words, if a program is using a base class, it should be able to use any of its subtypes without knowing it.</p><h4>Motivation</h4><p>The motivation behind the LSP is to make sure that we can safely substitute a subtype for its base type. By adhering to the LSP, we can make sure that code that is written to use a base type will continue to work correctly when a subtype is used instead.</p><h4>Symptoms</h4><p>If a class violates the LSP, it may have several symptoms. For example, if a subtype behaves differently from its base type, this can cause unexpected behavior in the program. Additionally, if a subtype requires additional preconditions or invariants that are not needed for the base type, this can also cause issues.</p><pre>public class Notification <br>{<br>    public string Content { get; set; }<br>    public string Recipient { get; set; }<br>}<br><br>public class LoggingNotification : Notification <br>{<br>    public void LogNotification()<br>    {<br>        // Log notification<br>    }<br>}<br><br>public class NotificationService <br>{<br>    public void SendNotification(Notification notification)<br>    {<br>        // Send notification<br>    }<br><br>    public void LogNotification(LoggingNotification notification)<br>    {<br>        notification.LogNotification();<br>    }<br>}</pre><p>In the code example above, the NotificationService class violates the LSP by using a derived class (LoggingNotification) instead of its base class (Notification). This can lead to unexpected behavior because the LoggingNotification the class has additional functionality that the NotificationService class isn&#39;t designed to handle.</p><h4>Implementation</h4><p>In the context of a notification service, we can apply the LSP by making sure that each type of notification is substitutable for the base notification class. This means that we should be able to use any type of notification interchangeably without impacting the behavior of the program.</p><pre>public interface INotification <br>{<br>    string Content { get; set; }<br>    string Recipient { get; set; }<br>}<br><br>public interface ILoggingNotification : INotification <br>{<br>    void LogNotification();<br>}<br><br>public class Notification : INotification <br>{<br>    public string Content { get; set; }<br>    public string Recipient { get; set; }<br>}<br><br>public class LoggingNotification : ILoggingNotification <br>{<br>    public string Content { get; set; }<br>    public string Recipient { get; set; }<br><br>    public void LogNotification()<br>    {<br>        // Log notification<br>    }<br>}<br><br>public class NotificationService <br>{<br>    public void SendNotification(INotification notification)<br>    {<br>        // Send notification<br>    }<br><br>    public void LogNotification(ILoggingNotification notification)<br>    {<br>        notification.LogNotification();<br>    }<br>}</pre><p>In the code example above, we&#39;ve implemented the LSP by using interfaces instead of classes for our types. We have an INotification interface that the Notification class implements, and an ILoggingNotification interface that the LoggingNotification class implements. The NotificationService class depends on these interfaces instead of the concrete classes.</p><h3>Interface Segregation Principle (ISP)</h3><p>The Interface Segregation Principle (ISP) states that clients should not be forced to depend on interfaces they don’t use. In other words, we should separate large interfaces into smaller, more specific interfaces that clients can use as needed.</p><h4>Motivation</h4><p>The motivation behind the ISP is to make sure that we’re not forcing clients to implement functionality they don’t need. By separating interfaces into smaller, more specific ones, we can make sure that clients can use only the functionality they need, which can reduce code complexity and increase maintainability.</p><h4>Symptoms</h4><p>If a class violates the ISP, it may have several symptoms. For example, the class may be implementing methods that it doesn’t need, or it may be dependent on an interface that is too large or complex.</p><pre>public interface INotification <br>{<br>    string Content { get; set; }<br>    string Recipient { get; set; }<br><br>    void SendNotification();<br>    void LogNotification();<br>    bool ValidateNotification();<br>}<br><br>public class Notification : INotification <br>{<br>    public string Content { get; set; }<br>    public string Recipient { get; set; }<br><br>    public void SendNotification()<br>    {<br>        // Send notification<br>    }<br><br>    public void LogNotification()<br>    {<br>        // Log notification<br>    }<br><br>    public bool ValidateNotification()<br>    {<br>        // Validate notification<br>        return true;<br>    }<br>}<br><br>public class NotificationService <br>{<br>    public void SendNotification(INotification notification)<br>    {<br>        if (notification.ValidateNotification())<br>        {<br>            notification.SendNotification();<br>        }<br>        else<br>        {<br>            notification.LogNotification();<br>        }<br>    }<br>}</pre><p>In the code example above, the INotification interface violates the ISP because it has too many methods that aren’t relevant to all its implementors. Specifically, the SendNotification() method isn&#39;t relevant to the Notification class, which only needs to define the content and recipient of the notification.</p><h4>Implementation</h4><p>In the context of a notification service, we can apply the ISP by separating the notification interface into smaller, more specific interfaces. For example, we might have an interface for sending email notifications, an interface for sending SMS notifications, and an interface for sending push notifications. Clients can then implement only the interfaces they need, which can reduce code complexity and increase maintainability.</p><pre>public interface INotification <br>{<br>    string Content { get; set; }<br>    string Recipient { get; set; }<br>}<br><br>public interface ISendableNotification : INotification <br>{<br>    void SendNotification();<br>}<br><br>public interface ILoggableNotification : INotification <br>{<br>    void LogNotification();<br>}<br><br>public interface IValidatableNotification : INotification <br>{<br>    bool ValidateNotification();<br>}<br><br>public class Notification : INotification <br>{<br>    public string Content { get; set; }<br>    public string Recipient { get; set; }<br>}<br><br>public class EmailNotification : ISendableNotification, ILoggableNotification, IValidatableNotification <br>{<br>    public string Content { get; set; }<br>    public string Recipient { get; set; }<br><br>    public void SendNotification()<br>    {<br>        // Send email notification<br>    }<br><br>    public void LogNotification()<br>    {<br>        // Log email notification<br>    }<br><br>    public bool ValidateNotification()<br>    {<br>        // Validate email notification<br>        return true;<br>    }<br>}<br><br>public class SmsNotification : ISendableNotification, IValidatableNotification <br>{<br>    public string Content { get; set; }<br>    public string Recipient { get; set; }<br><br>    public void SendNotification()<br>    {<br>        // Send SMS notification<br>    }<br><br>    public bool ValidateNotification()<br>    {<br>        // Validate SMS notification<br>        return true;<br>    }<br>}<br><br>public class NotificationService <br>{<br>    public void SendNotification(ISendableNotification notification)<br>    {<br>        if (notification.ValidateNotification())<br>        {<br>            notification.SendNotification();<br>        }<br>        else<br>        {<br>            ((ILoggableNotification)notification).LogNotification();<br>        }<br>    }<br>}</pre><p>In the code example above, we&#39;ve implemented the ISP by breaking the INotification interface into smaller, more specific interfaces (ISendableNotification, ILoggableNotification, and IValidatableNotification). The Notification the class now only implements the INotification interface, while the EmailNotification and SmsNotification classes implement the appropriate combination of interfaces. The NotificationService class depends on the more specific interfaces instead of the larger, more general INotification interface.</p><h3>Dependency Inversion Principle (DIP)</h3><p>The Dependency Inversion Principle (DIP) states that high-level modules should not depend on low-level modules. Instead, both should depend on abstractions. In other words, we should depend on abstractions, not on concrete implementations.</p><h4>Motivation</h4><p>The motivation behind the DIP is to make sure that our code is flexible and easy to change. By depending on abstractions instead of concrete implementations, we can make sure that changes to the underlying implementation don’t impact the higher-level modules.</p><h4>Symptoms</h4><p>If a class violates the DIP, it may have several symptoms. For example, it may be difficult to change the implementation of a class without impacting other parts of the system. Additionally, if a class has too many dependencies, this can lead to tight coupling and increased complexity.</p><pre>public class EmailNotificationSender <br>{<br>    public void SendEmail(Notification notification)<br>    {<br>        // Send email notification<br>    }<br>}<br><br>public class SmsNotificationSender <br>{<br>    public void SendSms(Notification notification)<br>    {<br>        // Send SMS notification<br>    }<br>}<br><br>public class NotificationService <br>{<br>    private readonly EmailNotificationSender _emailSender;<br>    private readonly SmsNotificationSender _smsSender;<br><br>    public NotificationService()<br>    {<br>        _emailSender = new EmailNotificationSender();<br>        _smsSender = new SmsNotificationSender();<br>    }<br><br>    public void SendNotification(Notification notification)<br>    {<br>        if (notification.Type == NotificationType.Email)<br>        {<br>            _emailSender.SendEmail(notification);<br>        }<br>        else if (notification.Type == NotificationType.Sms)<br>        {<br>            _smsSender.SendSms(notification);<br>        }<br>    }<br>}</pre><p>In the code example above, the NotificationService class violates the DIP by depending on the concrete EmailNotificationSender and SmsNotificationSender classes. This can make the code less flexible and harder to test because changes to these classes could affect the NotificationService class.</p><h4>Implementation</h4><p>In the context of a notification service, we can apply the DIP by depending on abstractions instead of concrete implementations. For example, we might have an interface for the notification service, which can be implemented by different types of notification classes. This way, we can change the implementation of the notification service without impacting the higher-level modules that depend on it.</p><pre>public interface INotificationSender <br>{<br>    bool CanSend(Notification notification);<br>    void SendNotification(Notification notification);<br>}<br><br>public class EmailNotificationSender : INotificationSender<br>{<br>  public bool CanSend(Notification notification)<br>  {<br>    return notification.Type == NotificationType.Email;<br>  }<br><br>  public void SendNotification(Notification notification)<br>  {<br>      // Send email notification<br>  }<br>}<br><br>public class SmsNotificationSender : INotificationSender<br>{<br>  public bool CanSend(Notification notification)<br>  {<br>    return notification.Type == NotificationType.Sms;<br>  }<br><br>  public void SendNotification(Notification notification)<br>  {<br>      // Send SMS notification<br>  }<br>}<br><br>public class NotificationService<br>{<br>  private readonly IEnumerable&lt;INotificationSender&gt; _senders;<br>  <br>  public NotificationService(IEnumerable&lt;INotificationSender&gt; senders)<br>  {<br>      _senders = senders;<br>  }<br>  <br>  public void SendNotification(Notification notification)<br>  {<br>      var sender = _senders.FirstOrDefault(s =&gt; s.CanSend(notification));<br>      <br>      if (sender == null)<br>      {<br>          throw new InvalidOperationException(&quot;No sender available for notification type.&quot;);<br>      }<br>      <br>      sender.SendNotification(notification);<br>  }<br>}</pre><p>In the code example above, we’ve implemented the DIP by defining the INotificationSender interface that abstracts the sending of notifications. The EmailNotificationSender and SmsNotificationSenderclasses now implement the INotificationSender interface, which defines both the CanSend()and SendNotification() methods. The `NotificationService` class now depends on the `INotificationSender` interface instead of the concrete sender classes. This makes the code more flexible and easier to test because we can inject any implementation of the INotificationSender interface into the NotificationServiceclass.</p><h3>Conclusion</h3><p>Solid principles are a set of five object-oriented design principles that can help us create code that is flexible, maintainable, and easy to change. By applying these principles to a notification service implemented in C#, we can create a system that is easy to understand, test, and maintain. By adhering to the SRP, OCP, LSP, ISP, and DIP, we can create code that is well-organized, flexible, and easy to modify, which can save time and effort in the long run.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=298944c083b4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to Enable a Plugin on a CS:GO Server using C# and RCON]]></title>
            <link>https://medium.com/@unhandlederror/how-to-enable-a-plugin-on-a-cs-go-server-using-c-and-rcon-cdb15a3a7380?source=rss-1c52f9962831------2</link>
            <guid isPermaLink="false">https://medium.com/p/cdb15a3a7380</guid>
            <category><![CDATA[csgo]]></category>
            <category><![CDATA[rcon]]></category>
            <category><![CDATA[game-server]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[plugins]]></category>
            <dc:creator><![CDATA[Rexhep Kqiku (/rdʒep ktʃi:ku:/)]]></dc:creator>
            <pubDate>Wed, 15 Feb 2023 23:48:24 GMT</pubDate>
            <atom:updated>2023-02-15T23:48:24.049Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*RzOQTfnKbvdTwU8c" /><figcaption>Photo by <a href="https://unsplash.com/@elladon?utm_source=medium&amp;utm_medium=referral">ELLA DON</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>If you’re running a Counter-Strike: Global Offensive (CS:GO) server, you may want to enable plugins to add new features and functionality to your server. However, enabling plugins on a CS:GO server can be a tricky process, especially if you’re not familiar with the game’s RCON (remote console) interface. In this post, we’ll show you how to enable a plugin on a CS:GO server using C# and the RconSharp library, as well as explore some alternative C# libraries for working with RCON.</p><p>First, let’s talk a bit about RCON. RCON is a protocol used by many game servers, including CS:GO, that allows you to send commands to the server’s console from a remote client. This can be useful for configuring the server, running admin commands, and enabling plugins, among other things.</p><p>To use RCON with a CS:GO server, you’ll need to connect to the server’s RCON console using an RCON client. In this post, we’ll be using the RconSharp library, which provides a simple interface for communicating with a CS:GO server’s RCON console using C#.</p><p>To get started, you’ll first need to install the RconSharp package in your C# project. You can do this using the NuGet package manager, by running the following command in the Package Manager Console:</p><p>Install-Package RconSharp</p><p>Once you’ve installed the RconSharp package, you can use the Rcon class to connect to the CS:GO server&#39;s RCON console and send the necessary commands. Here&#39;s an example:</p><pre>using RconSharp;<br><br>var rcon = new Rcon(&quot;server-ip-address&quot;, port, &quot;rcon-password&quot;);<br>rcon.Connect();</pre><p>Replace “server-ip-address”, port, and &quot;rcon-password&quot; with the appropriate values for your CS:GO server.</p><p>Once you’ve connected to the RCON console, you can send the necessary commands to enable the plugin. Here’s an example:</p><pre>var response = rcon.SendCommand(&quot;rcon meta load myplugin&quot;);<br>Console.WriteLine(response);</pre><p>This sends the command “rcon meta load myplugin” to the RCON console, which should enable the “myplugin” plugin. The response from the server is stored in the response variable, and printed to the console for debugging purposes.</p><p>After you’re finished using the RconSharp library, be sure to disconnect from the RCON console to release any resources. You can do this by calling the Disconnect method:</p><pre>rcon.Disconnect();</pre><p>This disconnects from the RCON console and releases any resources used by the Rcon object.</p><p>While RconSharp is a popular library for working with RCON in C#, there are other options available as well. One alternative is the SourceRcon library, which provides a similar interface for communicating with the RCON console. Here’s an example of how to use SourceRcon to enable a plugin on a CS:GO server:</p><pre>using SourceRcon;<br><br>var rcon = new Rcon(&quot;server-ip-address&quot;, port, &quot;rcon-password&quot;);<br>rcon.Connect();<br>var response = rcon.SendCommand(&quot;sm plugins load myplugin&quot;);<br>Console.WriteLine(response);<br>rcon.Disconnect();</pre><p>This code is similar to the RconSharp example, but uses the SourceRcon.Rcon class instead. Note that the command to enable the plugin is slightly different (&quot;sm plugins load myplugin&quot; instead of &quot;rcon meta load myplugin&quot;), as the syntax may vary</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cdb15a3a7380" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to Run Docker Compose from Another Directory]]></title>
            <link>https://medium.com/@unhandlederror/how-to-run-docker-compose-from-another-directory-e94e081a80cc?source=rss-1c52f9962831------2</link>
            <guid isPermaLink="false">https://medium.com/p/e94e081a80cc</guid>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[development]]></category>
            <category><![CDATA[containers]]></category>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[automation]]></category>
            <dc:creator><![CDATA[Rexhep Kqiku (/rdʒep ktʃi:ku:/)]]></dc:creator>
            <pubDate>Wed, 08 Feb 2023 23:48:21 GMT</pubDate>
            <atom:updated>2023-02-08T23:48:21.903Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*J4bCttafLDCe_1E4" /><figcaption>Photo by <a href="https://unsplash.com/pt-br/@carrier_lost?utm_source=medium&amp;utm_medium=referral">Ian Taylor</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Docker Compose is a powerful tool that allows you to define and run multi-container applications using a simple YAML file. It provides a convenient way to manage and orchestrate containers, networks, and volumes, making it easier to develop and deploy applications in a containerized environment.</p><p>However, when you run Docker Compose from a different directory than the one containing the docker-compose.yml file, you may encounter an issue where Docker Compose tries to create a new set of containers with the same name as an existing set of containers. This can happen if the Docker Compose project has the same name as a previous project that was run from a different directory.</p><p>To avoid this issue, you need to specify a unique project name when you run Docker Compose. This can be done using the -p or --project-name option.</p><p>Here is an example of how to run Docker Compose from a different directory while specifying a unique project name:</p><pre>docker-compose -f /path/to/project/docker-compose.yml -p my_project_name up</pre><p>In this example, -f specifies the path to the docker-compose.yml file, and -p specifies the project name as my_project_name.</p><p>Another option for running Docker Compose from a different directory is to navigate to the directory containing the docker-compose.yml file and then run Docker Compose without the -f option:</p><pre>cd /path/to/project<br>docker-compose up</pre><p>Additionally, the -d or --detach option can be used with the docker-compose up command to run the containers in the background and return control to the terminal. This allows you to run the containers in the background and perform other tasks in the terminal without having to wait for the containers to finish running.</p><pre>docker-compose -p custom_project_name -d up</pre><p>This command will start the containers defined in the docker-compose.yml file in the background, using custom_project_name as the project name for the containers, networks, and volumes.</p><p>In conclusion, running Docker Compose from a different directory than the one containing the docker-compose.yml file requires some extra steps to ensure that the containers created by Docker Compose have unique names. By specifying a unique project name using the -p or --project-name option, you can avoid any potential issues and run Docker Compose from a different directory without any problems.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e94e081a80cc" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to Pass Parameters to a Shell Script and Check for their Availability]]></title>
            <link>https://medium.com/@unhandlederror/how-to-pass-parameters-to-a-shell-script-and-check-for-their-availability-33ccf39cf9f4?source=rss-1c52f9962831------2</link>
            <guid isPermaLink="false">https://medium.com/p/33ccf39cf9f4</guid>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[unix]]></category>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[terminal]]></category>
            <category><![CDATA[shell]]></category>
            <dc:creator><![CDATA[Rexhep Kqiku (/rdʒep ktʃi:ku:/)]]></dc:creator>
            <pubDate>Wed, 08 Feb 2023 23:13:50 GMT</pubDate>
            <atom:updated>2023-02-08T23:13:50.455Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*jigL-KbmoJYQmvpQ" /><figcaption>Photo by <a href="https://unsplash.com/@etiennegirardet?utm_source=medium&amp;utm_medium=referral">Etienne Girardet</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Shell scripts are powerful tools for automating tasks in Unix-like operating systems. They allow you to automate complex tasks and control the execution of other command-line utilities and applications. One of the key features of shell scripts is the ability to pass parameters to them and use these parameters to control the behavior of the script. In this blog post, we’ll explain how to pass parameters to a shell script and check for their availability in the script.</p><p>Passing Parameters to a Shell Script</p><p>In a shell script, you can access the values of positional parameters passed to the script using the special variables $1, $2, $3, and so on. For example, consider the following shell script:</p><pre>echo &quot;First parameter: $1&quot;<br>echo &quot;Second parameter: $2&quot;<br>echo &quot;Third parameter: $3&quot;</pre><p>This script takes three parameters and displays their values. To run this script and pass parameters to it, you would type the following command:</p><pre>./script.sh parameter1 parameter2 parameter3</pre><p>When you run this command, the script will display the following output:</p><pre>First parameter: parameter1<br>Second parameter: parameter2<br>Third parameter: parameter3</pre><h3>Checking for the Availability of Parameters</h3><p>It’s important to check if the required parameters have been passed to the script, to avoid errors or unexpected behavior. You can check for the availability of a positional parameter in a shell script using the [ -z &quot;$1&quot; ] expression, which tests if the value of the parameter is empty (i.e., if it doesn&#39;t exist or doesn&#39;t have a value).</p><p>Here’s an example of a shell script that checks for the availability of two required parameters and exits with an error message if either of them is missing:</p><pre>if [ -z &quot;$1&quot; ]; then<br>  echo &quot;Error: missing first parameter.&quot;<br>  exit 1<br>fi<br>if [ -z &quot;$2&quot; ]; then<br>  echo &quot;Error: missing second parameter.&quot;<br>  exit 1<br>fi<br># rest of the script</pre><p>In this script, the if [ -z &quot;$1&quot; ] and if [ -z &quot;$2&quot; ] statements check for the availability of the first and second parameters, respectively. If either of these parameters is missing, the script displays an error message and exits with a status code of 1 using the exit command.</p><p>You can also write a function to check for the availability of a parameter and call this function from different parts of your script as needed. Here’s an example of a function that checks for the availability of a parameter and returns an error message if it’s missing:</p><pre>function isParamAvailable {<br>  local param=$1<br>  if [ -z &quot;$param&quot; ]; then<br>    echo &quot;Error: missing parameter.&quot;<br>    exit 1<br>  fi<br>}</pre><pre>isParamAvailable &quot;$1&quot;<br>isParamAvailable &quot;$2&quot;</pre><p>In this example, the function isParamAvailable takes a parameter and stores its value in a local variable param. It then uses the [ -z &quot;$param&quot; ] expression to check if the value of param is empty. If the value of param is empty, the function displays an error message and exits with a status code of 1. The function can be called multiple times, with different parameters.</p><p>The goal of this article is to provide an understanding of how to pass parameters to a shell script, declare and use variables, and check if a parameter exists or has a value in a shell script. It provides a simple and concise explanation of the basic concepts of shell scripting, which is crucial for writing scripts to automate tasks, manage configuration files, and deploy software. By following the tips and examples provided in this article, you can start writing shell scripts that are effective, efficient, and easy to maintain.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=33ccf39cf9f4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Downloading all reports from SQL Server Reporting Service (SSRS)]]></title>
            <link>https://medium.com/@unhandlederror/download-all-ssrs-sql-server-reporting-service-reports-b267956a45b7?source=rss-1c52f9962831------2</link>
            <guid isPermaLink="false">https://medium.com/p/b267956a45b7</guid>
            <category><![CDATA[sql]]></category>
            <category><![CDATA[microsoft]]></category>
            <category><![CDATA[ssrs]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[powershell]]></category>
            <dc:creator><![CDATA[Rexhep Kqiku (/rdʒep ktʃi:ku:/)]]></dc:creator>
            <pubDate>Tue, 14 Aug 2018 14:31:17 GMT</pubDate>
            <atom:updated>2018-08-14T20:26:16.571Z</atom:updated>
            <content:encoded><![CDATA[<p>Here is my story:<br>I wanted to download all the SSRS reports (rdl), data sets (rsd) and data sources (rsds) from a remote server, that I can access only using VPN connection, on my local SQL Server Reporting Server instance.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*qvGGuu0o5ndZYGpl" /><figcaption>“A two-monitor computer setup with lines of code displayed on one of the screens” by <a href="https://unsplash.com/@leecampbell?utm_source=medium&amp;utm_medium=referral">Lee Campbell</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>First things first, I googled and found this great Reporting Services PowerShell tool <a href="https://github.com/Microsoft/ReportingServicesTools">https://github.com/Microsoft/ReportingServicesTools</a><br>It’ll help you to do a lot of things, but in my case, it helped me downloading all the reports from the remote server and with exact folder structure. Great!</p><p>To cut the long story short, let me tell you how I did it and what were the problems during this short journey.</p><p>First you need to install Reporting Services PowerShell. Open PowerShell and run the commands below :</p><pre># — — — — — — — — — — — — — — — — — — — — — — — — — — — <br>#Prerequisites<br>#Install-Module -Name ReportingServicesTools<br># — — — — — — — — — — — — — — — — — — — — — — — — — — —<br>#Lets get security on all folders in a single instance<br># — — — — — — — — — — — — — — — — — — — — — — — — — — — <br>#Declare SSRS URI<br>$sourceRsUri = &#39;<a href="http://reportserverurl/ReportServer/ReportService2010.asmx?wsdl&#39;">http://ReportServerURL/ReportServer/ReportService2010.asmx?wsdl&#39;</a></pre><pre>#Declare Proxy so we dont need to connect with every command<br>$proxy = New-RsWebServiceProxy -ReportServerUri $sourceRsUri</pre><pre>#Output ALL Catalog items to file system<br>Out-RsFolderContent -Proxy $proxy -RsFolder / -Destination ‘C:\SSRS_Out’ -Recurse</pre><p>(Code above was taken from <a href="https://stackoverflow.com/questions/46783093/download-all-ssrs-reports">https://stackoverflow.com/questions/46783093/download-all-ssrs-report)</a></p><p>After you execute <strong>$proxy = New-RsWebServiceProxy -ReportServerUri $sourceRsUri</strong> chances are to get the error below:<br><em>The ‘New-RsWebServiceProxy’ command was found in the module ‘ReportingServicesTools’, but the module could not be loaded. For more information, run ‘Import-Module ReportingServicesTools’</em></p><p>To overcome the above problem, you should go here <a href="https://stackoverflow.com/questions/40987109/the-save-module-command-was-found-in-the-module-powershellget-but-the-modul">https://stackoverflow.com/questions/40987109/the-save-module-command-was-found-in-the-module-powershellget-but-the-modul</a> and follow the correct answer or execute the following command:</p><pre>Set-ExecutionPolicy RemoteSigned -Scope CurrentUser</pre><p>Once you fix it, it’s time for the next error to be fixed, if you are accessing a remote server, otherwise accessing local instance won’t be a problem. The next error is called:<br><em>Failed to establish proxy connection to {Reporting Service URI}: There was an error downloading {Reporting Service URI}.</em></p><p>It’s not something you should be scared about, you just have to add an additional parameter when declaring the proxy and everything(I hope) will be OK.</p><pre>$proxy = New-RsWebServiceProxy -ReportServerUri $sourceRsUri -Credential ‘localuser’</pre><p>It’s obvious that the latest parameters asks for user credentials to access the server and once you execute it, it’ll prompt for the password. I’m not sure if it has to be a local admin or not, but definitely it should have permission to access Reporting Server Database.</p><h3>What I’m doing next?</h3><p>Since I don’t know for sure what does below command exactly do:</p><pre>Set-ExecutionPolicy RemoteSigned -Scope CurrentUser</pre><p>I’m going to reset Execution Policy using the command below:</p><pre>Set-ExecutionPolicy Undefined</pre><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b267956a45b7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Deleting it softly with EF Core]]></title>
            <link>https://medium.com/@unhandlederror/deleting-it-softly-with-ef-core-5f191db5cf72?source=rss-1c52f9962831------2</link>
            <guid isPermaLink="false">https://medium.com/p/5f191db5cf72</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[csharp]]></category>
            <category><![CDATA[dotnet]]></category>
            <category><![CDATA[entity-framework-core]]></category>
            <category><![CDATA[entity-framework]]></category>
            <dc:creator><![CDATA[Rexhep Kqiku (/rdʒep ktʃi:ku:/)]]></dc:creator>
            <pubDate>Mon, 23 Jul 2018 21:03:56 GMT</pubDate>
            <atom:updated>2018-07-23T21:11:05.639Z</atom:updated>
            <content:encoded><![CDATA[<p>“If you have to shoot, do shoot! But, if you have to delete, do soft delete”</p><p>But, I decided to sing a song:<br><em>Strumming my pain with my fingers<br>Singing my life with my code<br>Delete it softly with EF Core (2x)</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*wQ9HzbuyydYKHokD" /><figcaption>Just a random image on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a>. It has to do nothing with the post, you should skip it.</figcaption></figure><p>I don’t know how you did it, or did you do it at all, but soft deletion is now quite easy to be implemented in Entity Framework Core and you don’t have an excuse to not implement it properly.<br>You remember that <em>IsActive</em> or <em>IsDeleted</em> property that is everywhere in your code? Is the lambda expression below quite familiar to you?</p><pre>DbContext.Posts.Where(p =&gt; [some conditions] <strong>&amp;&amp; !p.IsDeleted</strong>)</pre><p>EF Core Team has introduced something that they call Global Query Filters. The idea behind those filters is not to offer an out-of-the-box soft delete implementation, but to offer a more reliable approach how to deal with conditions in a global level, if I can say.</p><p>Let’s not lose the time talking, I’m copying and pasting some code directly from Microsoft Docs</p><pre>public class Blog<br>{<br>    private string _tenantId;</pre><pre>    public int BlogId { get; set; }<br>    public string Name { get; set; }<br>    public string Url { get; set; }</pre><pre>    public List&lt;Post&gt; Posts { get; set; }<br>}</pre><pre>public class Post<br>{<br>    public int PostId { get; set; }<br>    public string Title { get; set; }<br>    public string Content { get; set; }<br>    public bool IsDeleted { get; set; }</pre><pre>    public int BlogId { get; set; }<br>    public Blog Blog { get; set; }<br>}</pre><p>In the past, if we would like to implement soft deletion in an application like this, then everywhere when we should list the posts, our <em>where</em> clause should contain an additional expression to prevent database context retrieving posts where <em>IsDeleted</em> is true. That means breaking the Don’t Repeat Yourself (DRY) principle, which is not good!</p><p>Using the Global Query Filter in EF Core we are able to prevent retrieving posts, that are deleted, on DbContext class level exactly OnModelCreating method using HasQueryFilter — which is a method of EntityTypeBuilder class. And to be more descriptive and precise, an instance of EntityTypeBuilder is returned by Entity method of ModelBuilder, Entity&lt;Post&gt;() in our case.</p><pre>public class BlogContext:DbContext<br>{<br> //Constructors, overriding OnConfiguring etc..<br> ...<br> <br> public DbSet&lt;Blog&gt; Blogs { get; set; }<br> public DbSet&lt;Post&gt; Posts { get; set; }</pre><pre> protected override void OnModelCreating(ModelBuilder modelBuilder)<br> {            <br>  // Configure entity filters<br>  ...</pre><pre>  modelBuilder.Entity&lt;Post&gt;()<strong>.HasQueryFilter(p =&gt; !p.IsDeleted)</strong>;<br> }<br>}</pre><p>It’s cool I think, isn’t it?</p><p>But, wait! What about cases when saving it’s deletion state, is there any chance to manage it from DbContext class? Of course it is, watch out the code below:</p><pre>public override int SaveChanges()<br>{<br> ChangeTracker.DetectChanges();<br> <br> foreach (var item in ChangeTracker.Entries&lt;Post&gt;()<br>  .Where(e =&gt; e.State == EntityState.Deleted))<br> {<br>  item.State = EntityState.Modified;<br>  <strong>item.CurrentValues[&quot;IsDeleted&quot;] = true;</strong><br> }</pre><pre> return base.SaveChanges();<br>}</pre><p>I think it is clear and the code speaks for itself; iterate through all deleted posts, change their state to modified, set the <em>IsDeleted</em> property to <em>true</em> and save it to the database<em>.</em></p><h3>Bonus</h3><p>There are cases when we need to list all the posts, even if they are soft deleted, let’s say on an admin panel page. EF Core has covered it already for us, just look at the line of code below:</p><pre>var blogs = db.Blogs.Include(b =&gt; b.Posts)<br>              .<strong>IgnoreQueryFilters()</strong>.ToList();</pre><p>When I started writing the post, I thought it will be short one and it’s not going to take me more than 15 minutes, but indeed it took me more . Doesn’t matter, I’m trying to push myself writing and I hope someone will benefit from my posts. If at any chance, it happens you like my posts, feel free to write it on the comments section.</p><p>You are still here!? Thank you for your patience!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5f191db5cf72" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The NoDev — Not Only Developer]]></title>
            <link>https://medium.com/@unhandlederror/the-nodev-not-only-developer-1e96083f0301?source=rss-1c52f9962831------2</link>
            <guid isPermaLink="false">https://medium.com/p/1e96083f0301</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[development]]></category>
            <category><![CDATA[developer]]></category>
            <dc:creator><![CDATA[Rexhep Kqiku (/rdʒep ktʃi:ku:/)]]></dc:creator>
            <pubDate>Tue, 22 May 2018 23:08:20 GMT</pubDate>
            <atom:updated>2018-05-24T10:43:11.605Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*mDPwX2Zcj-pPpjNj." /><figcaption>“Two people in elegant shirts brainstorming over a sheet of paper near two laptops” by <a href="https://unsplash.com/@helloquence?utm_source=medium&amp;utm_medium=referral">Helloquence</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>If you google types of developers, you’ll usually get a list like this (short version with a (funny) description):<br>* Front-end developer — knows how to use, at least, one modern JS library<br>* Backend developer — knows how to return a well-formatted JSON file<br>* Mobile developer — knows how to build a desktop app in mobile devices<br>* Full-stack developer — pretends to know all above, even more<br>* etc</p><p>A definition for each one of them is a coding-ninja in a specific field of software development. You could imagine a person in front of his device/s (PC, Mac, Mobile devices etc.), stuck to his chair, grabbing as many issues as he can from a backlog in Jira and make them done. Other than this, he designs, implements, tests, deploys, automates pieces of software or systems, both — big and small. But, at the end of the day, he is just a developer — and it’s not an easy job!</p><h3>NoDev — Not Only Developer</h3><p>Inspired by NoSQL acronym — which stand for “Not Only SQL” and is an alternative to traditional relational databases, NoSQL databases are especially useful for working with large sets of distributed data — I’m about to invent a new term to describe a specific developer profile.</p><p>A <strong>NoDev </strong>can be a front-end, back-end, mobile, full-stack, whatever developer, but beyond this:<br>- You are not afraid to invite him in different client meetings<br>- Even more, you are not afraid to let him meet the client alone <br>- He is excellent in gathering system requirements<br>- He has excellent knowledge in different domains (areas he worked in)<br>- In some cases, he is better or equal to a business analyst<br>- Except for APIs and software documentation, he prepares excellent technical documentation<br>- He evaluates technical conversations<br>- Solves problems without using any single line of code<br>- Has developed and run, at least one product aside from his daily job<br>- He is always ready to jump in legacy systems and handle them like a pro, even he does not feel comfortable doing this<br>- Excels on converting business requirements to technical implementation<br>- Can optimize project deliverables with quality &amp; expenses in mind<br>- Knows what makes a good product<br>- (list may be updated in the future)<br>* *Credit goes to <a href="https://www.linkedin.com/in/elban-avdylaj-94507838/">Elban Avdylaj</a> for last three ones</p><p>The idea behind this article and NoDev term is that most of developers used to stick to their area of specialization(adding more languages/frameworks on their tool belt) and are not ready to meet the world outside of their contexts, and some companies are super happy if they find a person who can develop new features or fix bugs for six hours, and is ready to meet the client and gather requirements for the next remaining working hours.</p><p>The true story happened weeks ago when a friend of mine, developer of course, in an interview said that except he is a good developer, he is also good at gathering system requirements, the interviewer on the other side almost died from happiness — in the end, he was able to find a developer ready to move from his chair, a NoDev.</p><p>If I’m not going to use this term for myself, none will do it. So, starting from today, I’ll put “NoDev — Not Only Developer” on my profile description.</p><p>Let me know if you did it too.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1e96083f0301" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Co-authored: Why you need Null Object Pattern and how to implement it]]></title>
            <link>https://medium.com/@unhandlederror/co-authored-why-you-need-null-object-pattern-and-how-to-implement-it-83f6aacf3f4f?source=rss-1c52f9962831------2</link>
            <guid isPermaLink="false">https://medium.com/p/83f6aacf3f4f</guid>
            <category><![CDATA[csharp]]></category>
            <category><![CDATA[exception]]></category>
            <category><![CDATA[patterns]]></category>
            <category><![CDATA[dotnet]]></category>
            <category><![CDATA[coding]]></category>
            <dc:creator><![CDATA[Rexhep Kqiku (/rdʒep ktʃi:ku:/)]]></dc:creator>
            <pubDate>Thu, 10 May 2018 18:57:21 GMT</pubDate>
            <atom:updated>2018-05-10T18:57:21.653Z</atom:updated>
            <content:encoded><![CDATA[<p>Weeks ago I did a quick post in one of our local group about Null Object Pattern. It was in Albanian and sooo .Net specific, so I asked <a href="https://medium.com/u/bb10e3af0759">Fatos Morina</a> to Englishify, iron and smooth it; of course he went beyond my expectations and did a great post you can find here:</p><p><a href="https://hackernoon.com/why-you-need-null-object-pattern-and-how-to-implement-it-16a96b04125f">https://hackernoon.com/why-you-need-null-object-pattern-and-how-to-implement-it-16a96b04125f</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=83f6aacf3f4f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Setup .NET development environment on your Mac within 15 minutes]]></title>
            <link>https://medium.com/@unhandlederror/setup-net-development-environment-on-your-mac-within-15-minutes-7add1e7fd375?source=rss-1c52f9962831------2</link>
            <guid isPermaLink="false">https://medium.com/p/7add1e7fd375</guid>
            <category><![CDATA[microsoft-dot-net]]></category>
            <category><![CDATA[visual-studio]]></category>
            <category><![CDATA[mssql]]></category>
            <category><![CDATA[sql-server]]></category>
            <category><![CDATA[docker]]></category>
            <dc:creator><![CDATA[Rexhep Kqiku (/rdʒep ktʃi:ku:/)]]></dc:creator>
            <pubDate>Mon, 23 Apr 2018 21:38:08 GMT</pubDate>
            <atom:updated>2018-04-27T13:32:04.145Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*vKmMTCNC2ZANdzEG." /><figcaption>Photo by <a href="https://unsplash.com/@tsbcreative?utm_source=medium&amp;utm_medium=referral">Andy Hall</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>I was sitting in front of my Mac and didn’t want to waste time switching to my Lenovo windows based laptop.. but the problem was:<br>One of the project I’m working on is built using .NET Core, EF Core Migrations and it’s configured to use MS SQL Server, so how can I run it on my Mac!?</p><p>Let’s start…</p><h3>Visual Studio for Mac</h3><p>Designed natively for the Mac<br>Visual Studio for Mac brings the developer productivity you love to the Mac. The experience has been meticulously crafted to optimize the developer workflow for the Mac.</p><p>The paragraph above I took from VS website, so click the link (<a href="https://www.visualstudio.com/vs/mac/">https://www.visualstudio.com/vs/mac/</a>) and download and install Visual Studio for Mac.</p><h3>MS SQL Server</h3><p>The best way to have MS SQL Server ready to use on your Mac is by running the SQL Server 2017 container image with Docker.</p><p><strong>How do they do it? <br></strong>Here you have a quickstart by Microsoft Docs<br><a href="https://docs.microsoft.com/en-us/sql/linux/quickstart-install-connect-docker?view=sql-server-linux-2017">https://docs.microsoft.com/en-us/sql/linux/quickstart-install-connect-docker?view=sql-server-linux-2017</a></p><p>In case you may have any trouble, as I did, please leave that quickstarter and follow the commands below:</p><p><strong>Pull the SQL Server 2017 Linux container image from Docker Hub.</strong></p><pre>sudo docker pull microsoft/mssql-server-linux:2017-latest</pre><p><strong>Run the container image with Docker</strong></p><pre>docker run \ --name mac-ms-sql \ --volume /Users/YourUser/Documents/DockerShared:/HostShared \ --env &#39;ACCEPT_EULA=Y&#39; \ --env &#39;MSSQL_SA_PASSWORD=P@ssw0rd&#39; \ --publish 1401:1433 \ --detach microsoft/mssql-server-linux:2017-latest</pre><p><strong>Make sure your Docker container is running</strong></p><pre>sudo docker ps -a</pre><h3>Connect to SQL Server instance</h3><p>Do not lose time using SQL Server command-line tool, click the link below to download and install SQL Operations Studio (preview):<br><a href="https://docs.microsoft.com/en-us/sql/sql-operations-studio/download?view=sql-server-2017">https://docs.microsoft.com/en-us/sql/sql-operations-studio/download?view=sql-server-2017</a></p><p>Open SQL Operations Studio and connect to the MS SQL Server Docker instance, leave the defaults, except:<br>…<br>Server name: localhost<br>…<br>User name: sa<br>Password: P@ssw0rd<br>…</p><p>Click on <strong>Advanced</strong> button<br>…<br><strong>General </strong>section<br>Port: 1401<br>…<br>Click <strong>OK<br></strong>Click <strong>Connect</strong></p><p>You’re Done :)</p><p>SQL Operations Studio looks cooler than the famous MS SQL Server Management Studio(SSMS), doesn’t it? :)</p><p><strong>Known issues<br></strong>1. If you are getting this error “<strong>Cannot access kerberos ticket. ensure kerberos has been initialized with ‘kinit’</strong>…”, chances are you’ve using Integrated Authentication, I mean you are not using SQL authentication, which you should. So, just go ahead and update your connection string to:</p><pre>“DefaultConnection”:“Server=127.0.0.1,1401;Database=YourDBName;Uid=sa;Pwd=P@ssw0rd;MultipleActiveResultSets=true”</pre><p>2. Not yet discovered (list may be updated in future)</p><p><strong>Bonus</strong><br>In case you do not like instance name, or you did a typo during the setup, here are commands to remove the SQL Server container you just set up:</p><pre>sudo docker stop mac-ms-sql<br>sudo docker rm mac-ms-sql</pre><p><em>P.S. The post is meant for myself, in case I forget how to do it again, but if you find it useful, I’m happy ;)</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7add1e7fd375" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>