Ternaryis in the Business Process Management Software Industry

Ternary

ternary

So, in the previous parts of this series you’ve seen the basics of , PHP You have seen what are the basic constructs that this language gives you, You have already seen that there are several types of variables (divided into simple and composite). Now we have finished playing and we start doing things seriously! The question that today’s blog post will answer is: . “Now that I know how to create variables how can I insert them in the flow of my code?” The answer is: through operators, PHP operators allow you to move through the code, to update variables, to lead visitors of your web application to one direction or another (through the use of control structures). There are different types of operators, some that you will use every day many times a day, others that you will rarely use, but once you understand how they work they will make you a web developer much above average if not top 10% among your colleagues. PHP Basics for Expert Developers This blog post is part of a series called “ ”. PHP Basics for Expert Developers In this series, you are going to but you will also see many small tips and features that you will only find in books and . learn the basics of PHP advanced tutorials Depending on your level you may simply want to read them sporadically or skip them altogether. You do not have to learn all that is written here by heart! Simply read, find out that certain features or techniques exist and return to these pages when you feel ready for the next level. PHP basics for expert web developers (1' part) Construct and Comments of PHP 7 How to use variables (PHP 7) Composite variable in PHP (Arrays, Object and more) PHP Operators (Part 1) Also, this blog post is divided into a few main sections Arithmetic Operators Logic Operators Ternary Operator Null Coalescing Operator Spaceship Operator Bitwise Operators Conclusion Operators In PHP there are . different types of operators They range from arithmetic operators to logical operators through assignment operators, reference operators, spaceships and Bitwise. Each of them has its own well-defined purpose that you will see right now. Arithmetic Operators The arithmetic operators are the same ones that your teacher taught you at the elementary school. They are the then you got indicated by the symbol ** and indicated by the symbol %. additions, subtractions, divisions, multiplications, power modulus There are two types of arithmetic operators that take into account and operators that take into consideration only . two arguments (which are called binary) one argument (they are called unary) In turn, Unary operators are divided into two types: . Prefix and Postfix These types change depending on whether the operator appears before or after the variable you want to be changed. If the operator appears before the variable (Prefix) then the interpreter, the PHP parser will evaluate the operation and the changed variable will return. If instead, the operator appears after the variable (Postfix in this case) then the interpreter will return the variable as if the statement had never been executed and only after performing the operation requested on the variable. Logic Operators In order to understand what logical operators are, think of them as if they were conjugations in grammar. The purpose of using logical operators in programming languages such as PHP is to perform more complex conditions because it can, in fact, connect different conditions in one. These new conditions make operators more precise and easy to handle. There are seven different types of logical operators in PHP. They are divided into groups of 2. There are two “ ”, two “ ”, two “ ” and one “ ”. and or xor not They are paired because PHP uses both symbols and words to represent logical operators, thus, in a condition, you can write both the literal word “and” or the && symbol. The same applies to the word “or” or the symbol || and the word “xor” or ^. Logical operators are generally used between two conditions, creating a sort of bigger condition that will be true or false based on the relationship between the logical operator and the two conditions in use. If the operator is “and” or && for the main condition to be true, both conditions must be evaluated as true. In case it is the “or” or || operator between your statement for, the main condition to be evaluated as true one between the first and second condition must be evaluated as true, in the case of “xor” or ^ one of the two conditions must be evaluated as true but not both. “not” operator is the simplest one and it is indicated by the symbol “!” the condition is simply reversed to the current situation. Unlike the other logical operator the word: , which means the only way you can create a not statement is by prefix the condition with the symbol “!” “not” cannot be used in a condition Ternary Operator The use of the ternary operator is rather old. PHP uses the same format used by C, which is a programming language developed by Dennis Ritchie between 1969 and 1973. It consists of a condition followed by a question mark and then two expressions divided by a colon. If the condition is true then the first expression will be taken into consideration otherwise the expression taken into consideration will be the second one. Look at ternary operators as if they were simple if-else but for a simple operation like assignment or date echo, or at least here is where I find it more useful. Here is an example: echo (isset($var)) ? "the variable is set" : " the variable is not set "; As you can see the syntax in the example would be identical to an if-else statement. Once you’ve done some practice this line of code will be much easier to write. There is an even shorter version of this statement and it uses the symbol ?: . (do not ask me why) and consists in writing only the second expression. This version is called Elvis In this case, if the condition is true and the ternary operator has to assign a variable it will be evaluated as 1. This version is not suitable for testing, in fact, PHP will throw an error in this case $var = true; $result = (isset($var)) ?: " the variable is not set " ; echo $result; // $result will be 1 . Here is a brief explanation on the ternary operator from Wikipedia Null Coalescing Operator There is still another version of ternary operator (sort of) that is called a null coalescing operator or double question mark operator. . You will recognize it by the symbol ?? It allows verifying a condition with an even cleaner syntax through the use of two question marks. It is possible to assign a value to a variable if the variable in question has been set previously and is not null. Since the null coalescing operator reports no errors when you use it, it is better to use it instead of using the Elvis operator $result = $var ?? "Hello"; As you can see from the previous example if the variable present in the first expression has been set then the $result variable will take that value, otherwise, PHP will give the value to the right of the Operator Null Coalescing, in this case, the string “Hello”. This function also applies to multiple Null Coalescing Operators, It can be giving life to a series of conditions, as for the single, in PHP parser will follow the expressions on the right until it finds a valid value. chained one after another $result = $var ?? $var2 ?? "Hello"; Spaceship Operator Here is one of the operators preferred by PHP programmers, if nothing else, for its shape. The spaceship operator is used to analyze and compare two different values and is extremely useful for example when data must be ordered. The spaceship operator can return three different values. These are -1, 0 and 1. These values depend on the operands. If the operand on the left is less than the operand on the right then the spaceship operator will return -1 if the two values are equal it will return 0 if the second operand (the one on the right) is greater than the first operand (on the left) the value returned from spaceship operator will be 1. The spaceship operator also works in case you want to operate on strings, in fact, it is very useful for sorting words and letters. Keep in mind that with the same letter the one with the while the . smaller format will be considered major capital letter will be considered the minor see the examples below. 1 ⇔ 0// it will result in 11 ⇔ 1// it will result in 01 ⇔ 2// it will result in -1"variable" ⇔ "Variable"// it will result in 1 Have a look at the official manual for more about spaceship operator in PHP Bitwise Operators Bitwise operators work on integer bits. They are represented in binary form. There are three bitwise operators, The first is the AND operator which has a bit set if both operands are set then we have the bitwise OR operator which instead will have the result set if one or both of the operands has a set bit. Finally, which will have the result bit set only if one of the operands has the bit set, not both we have the bitwise operator XOR The result of this operation is simply the value we obtain after implementing these rules. I understand that this may seem like a very complicated concept. To make this concept simpler, you can think of these operations as if they represented a few decimal numbers. You can calculate the binary representation of the numbers simply by comparing from right to left and then convert to decimal when you finished. To make the concept even clearer below I will illustrate an example shown by the author Andrew Beak. Taking into consideration two numbers 50 and 25, To these two numbers, we implement the operator Bitwise AND. As you can see, following the rules are shown in precedence, as a result, we obtain the value 16, When we check the number the result is shown and an integer. Now I will show one of the weirdest operators in the whole PHP repertoire. You’ll read about Bit shifting! Bit shifting allows you to shift the bit pattern by value, you can choose to do either from the right or from the left side. To understand how Bit shifting works, think of a number as if it is shown in its binary form. If the reference is to the right the operator is called “Shift Right” and a bit is moved from the right side, if instead, we use the “Shift” Left “the operation will add a zero in the right part of the binary representation of the number in question. 50// Result in Binary 00110010 50 >> 1// Result in binary: 0011001// Result in decimal 25 50 << 1// Result in binary: 01100100// Result in decimal 100 Eventually, we have . bitwise not operator This instead is very simple to understand, to find the result of this bitwise operator just find the binary value of a number and reverse the 1 in 0 and vice versa. You will find great help in the base_convert() function that outputs the binary representation of a decimal number To help you understand more about the concept of bitwise and bitwise operator, I have included an amazing video created by EpicFactFind below. I hope you enjoy Conclusion What an interesting topic, isn’t it? I personally believe that PHP operators are the fundaments of every language. programming They are indispensable and, as you will see in the next chapters of this series (subscribe to my newsletter to get notified when published), you will make extensive use of them in control structures and other operations. As you’ve seen, some of them are really simple (I’m sure you have not had any trouble figuring out how to make an addition between two variables) but others like the “Elvis” operator or bitwise operations can create problems even for experienced programmers, Nonetheless, they are topics required in important exams such as the PHP Zend certificate. As you know, the main purpose of this series of blog posts, like others on my website, is to give you an extra kick to let your skills skyrocket, and with them your career. As always, if something is not clear to you and you want clarification on something written in this post feel free to send me an email or, even better, take advantage of the community on Facebook for help. link below. … Now you know the basics, it is time to start practising, Take advantage of the power and the speed of Blue Host and create an account where you can exercise and see your improvement on a live server at less than a Starbuck’s Caffe Mocha per month. (This is an affiliate link, The price stays the same for you and it helps me improve this content.) Originally published at anastasionico.uk .

PHP operators (part 1)

This article is aimed at beginners or anyone who may be unaware of what a Ternary Operator is. I’ve encountered a few peers who seemed completely unaware that these things exist! Ternary Comparisons are very situational but can make your code a bit more readable if used in the right situation. For the uninitiated a ternary operator looks like the following: /**
 * where are the kids going to play? 
 * let's look at the weather today.
 * 、ヽ｀、ヽ｀个c(ﾟ∀ﾟ∩)｀ヽ、｀ヽ、
 */

// ternary operator
$playArea = ($raining) ? "Inside" : "Outside"; 

// same logic using more traditional conditional statement
$playArea = "Outside";
if ($raining == True) {
  $playArea = "Inside";
}

// same logic using more traditional conditional statement
if ($raining) {
  $playArea = "Inside";
} else {
  $playArea = "Outside";
} For example, let’s say we have a template that shows two different strings in a div depending on a session variable. If a user is logged in we will welcome them back, otherwise, we will show our corporate slogan “A brand new start”. First, we will use conditional statements commonly seen inserted between HTML code: <?
// is user logged in?
session_start();
$isUserLoggedIn = $_SESSION["isUserLoggedIn "];
?>


<div class="main">
  <div class="hero welcome">
    <? if($isUserLoggedIn): ?> 
      A brand new start.
    <?php else: ?>
      Welcome back!
    <?php endif; ?>
  </div>
</div> Let’s revisit this example with an inline Ternary Operator condition: <?
// is user logged in?
session_start();
$isUserLoggedIn = $_SESSION["isUserLoggedIn "];
?>


<div class="main">
  <div class="hero welcome">
    <?= ($isUserLoggedIn) ? "A brand new start." : "Welcome back!" ?>
  </div>
</div> Quick Note: I am unable to find a definitive answer to the correct semantics regarding the correct use of the internet’s interchangeable use of “Ternary Operator”, “Ternary Expression” and “Ternary Conditional” in regards to its use within PHP development. I hope that adds a new tool to your toolbox, or maybe sheds light on someone else’s code that might be twisting your melon. Further reading PHP conditionals and comparison from the official documentation: https://www.php.net/manual/en/language.operators.comparison.php

Shorthand Comparisons using Ternary Operators in PHP

I ran into a problem in Perl the other day that has perplexed me since, simply because I haven’t yet found an answer to it. Here’s my problem. Take the following examples: Multi-Variable Assignment: Perl allows for declaring multiple variables at the same time using syntax like this: my ($var1, $var2) = (100, 200);print "variable 1 is: $var1, variable 2 is: $var2 \n\n"; This would return the following result: variable 1 is: 100, variable 2 is: 200 String Splitting: Easy enough right? Perl also allows for splitting a string, as do most languages. The syntax for splitting a string looks something like this: my $str1 = 'a sentence has many words';my = split / /, $str1; @arr1 foreach my $x ( ) {print "word: $x \n";} @arr1 The printed result from this example would give us the following: word: aword: sentenceword: hasword: manyword: words Ternary Operators: Lastly, Perl also allows for Ternary operators. These are a nice way of consolidating code, and keeping if else blocks all in one line, although there is some debate on which style is better and more readable. In any case, take the following string: my $str2 = 'This string has two sentences -  A dash separates them'; Now if we wanted to split this based on a conditional statement, we could do something like this: my ;if (index($str2, '-') != -1) { = split /-/,$str2;} else { = split /:/,$str2;}print "========== array7[0]", $arr7[0], "\n";print "========== array7[1]", $arr7[1], "\n"; @arr7 @arr7 @arr7 This code, would give us an output of the following: ========== array7[0]This string has two sentences========== array7[1]  A dash separates them However, we could get the same output writing less code by using a ternary operator. The above if/else block would give the same output if written as follows: my ( ) = (index($str2, '-') != -1) ? split /-/,$str2 : split /:/,$str2;print "arr2[0] is: ", $arr2[0], "\n";print "arr2[1] is: ", $arr2[1], "\n"; @arr2 Our output being: arr2[0] is: This string has two sentencesarr2[1] is:   A dash separates them Now lets take the if/else block from earlier, and add two arrays. We’ll set the value of each array in the if else block. Our two strings again are the following: my $str2 = 'This string has two sentences -  A dash separates them';my $str4 = 'This string has different punctuation; a semicolon'; Our conditional statement is: my ( , );if (index($str2, '?') != -1) { = split /j/,$str2; = split /k/,$str4;} else { = split /-/,$str2; = split /;/,$str4;} @arr5 @arr6 @arr5 @arr6 @arr5 @arr6 print "array 5[0] is: ", $arr5[0], "\n";print "array 5[1] is: ", $arr5[1], "\n"; print "array 6[0] is: ", $arr6[0], "\n";print "array 6[1] is: ", $arr6[1], "\n"; and our output being the following: array 5[0] is: This string has two sentencesarray 5[1] is:   A dash separates themarray 6[0] is: This string has different punctuationarray 6[1] is:  a semicolon This is where I get stuck: Now, it seems like, with all of this in mind, you should be able to combine all of the above into a one line ternary operator piece of code. We can declare multiple variables in a ternary block as we’ve seen earlier. So it seems like we should be able to do exactly the above code, but with a ternary instead of an if else block. Something like this: my ( , ) = (index($str2, '-') != -1) ? split /-/,$str2, split /;/, $str4 : split /:/,$str2, split /;/, $str4; @arr3 @arr4 This is basically doing the exact same thing, setting the value of the two arrays, in each part of the ternary conditional statement. However if we print the results: print "array 3[0] is: ", $arr3[0], "\n";print "array 3[1] is: ", $arr3[1], "\n"; print "array 4[0] is: ", $arr4[0], "\n";print "array 4[1] is: ", $arr4[1], "\n"; We get the following output: array 3[0] is: This string has two sentencesarray 3[1] is:   A dash separates themarray 4[0] is:array 4[1] is: Even if you put both evaluation blocks in parenthesis, it still yields the same results. My conclusion is that the additional comma in each split function throws off the ternary conditional block, and doesn’t catch the second group. However, this is just a guess, as I haven’t found an answer elsewhere. If anyone has any insight, I would be appreciative. Not that this would ever be a necessary thing to do in any real-world situation. But it just annoys me that it seems like it should work, but doesn’t, and I don’t know why!

Ternary Trouble in Perl

Generative AI: Expert Insights on Evolution, Challenges, and Future Trends

জেনারেটিভ এআই: বিবর্তন, চ্যালেঞ্জ এবং ভবিষ্যত প্রবণতা সম্পর্কে বিশেষজ্ঞের অন্তর্দৃষ্টি

Generative KI: Experteneinblicke in Entwicklung, Herausforderungen und zukünftige Trends

IA generativa: opiniones de expertos sobre la evolución, los desafíos y las tendencias futuras

IA générative : avis d'experts sur l'évolution, les défis et les tendances futures

जनरेटिव एआई: विकास, चुनौतियों और भविष्य के रुझानों पर विशेषज्ञ अंतर्दृष्टि

生成型 AI: 進化、課題、将来の動向に関する専門家の見解

생성적 AI: 진화, 과제 및 미래 동향에 대한 전문가의 통찰력

IA generativa: insights de especialistas sobre evolução, desafios e tendências futuras

Генеративный ИИ: экспертные взгляды на эволюцию, проблемы и будущие тенденции

Üretken Yapay Zeka: Gelişim, Zorluklar ve Gelecekteki Eğilimler Hakkında Uzman Görüşleri

AI sáng tạo: Thông tin chuyên sâu của chuyên gia về sự tiến hóa, thách thức và xu hướng tương lai

生成式人工智能：专家对演进、挑战和未来趋势的见解

Comprehensive Guide to JavaScript Arrays: Adding, Removing, and Iterating Elements

Next-Gen FHE Toolchains for the Dev Multiverse: How TFHE Is Taking Us There

দেব মাল্টিভার্সের জন্য নেক্সট-জেন এফএইচই টুলচেইন: হাউ টিএফএইচই আমাদের সেখানে নিয়ে যাচ্ছে

FHE-Toolchains der nächsten Generation für das Dev-Multiversum: Wie TFHE uns dorthin bringt

Cadenas de herramientas FHE de próxima generación para el multiverso de desarrollo: cómo TFHE nos lleva allí

Chaînes d'outils FHE de nouvelle génération pour le multivers de développement : comment TFHE nous y emmène

देव मल्टीवर्स के लिए अगली पीढ़ी के FHE टूलचेन: TFHE हमें वहां कैसे ले जा रहा है

開発マルチバース向けの次世代 FHE ツールチェーン: TFHE が私たちをそこへ導く方法

Dev Multiverse를 위한 차세대 FHE 툴체인: TFHE가 우리를 그곳으로 데려가는 방법

Conjuntos de ferramentas FHE de última geração para o multiverso de desenvolvimento: como o TFHE está nos levando até lá

Инструментальные цепочки нового поколения FHE для мультивселенной разработчиков: как TFHE ведет нас туда

Dev Multiverse için Yeni Nesil FHE Araç Zincirleri: TFHE Bizi Oraya Nasıl Götürüyor?

Chuỗi công cụ FHE thế hệ tiếp theo dành cho Đa vũ trụ Dev: TFHE đang đưa chúng ta đến đó như thế nào

面向 Dev Multiverse 的下一代 FHE 工具链：TFHE 如何带领我们实现这一目标

Why 1-Bit Transformers Will Change the World

Rosetta Stone and machine-interpretability: Wikidata and a modeling paradigm 

I’ve been writing code for 20+ years, and along the way, I’ve written a ton of code that I needed to go back and refactor. It happens. In fact, it’s almost guaranteed if you want to keep a codebase alive as you’re evolving it. As a result, I’ve done a lot of r C# code and want to share with you some simple refactoring techniques that can be especially useful if you’re just getting started. efactoring 1 – Extract Method Refactoring code is an important skill for software engineers, as it helps improve the readability and maintainability of our codebase. One such technique that can greatly assist us in achieving this goal is the Extract Method technique. I use this so frequently that almost immediately after I write some code I do this! The Concept of Extract Method The Extract Method technique involves taking a block of code within a method and extracting it into a separate method. By doing this, we can improve the clarity and understandability of our code by breaking it down into smaller, more manageable pieces. Don’t wait until you have a 2000-line method before you figure out why this is helpful! To demonstrate this technique, consider the following example in C#: public class Calculator
{
    public int Add(int a, int b)
    {
        Console.WriteLine($"Adding {a} and {b}...");
        int result = a + b;
        Console.WriteLine("The result is: " + result);
        return result;
    }
} In the above code, the method is responsible for: Add Printing out the calculation info Performing the addition operation Displaying the result It’s a pretty simple method, but it’s doing a handful of things already. By applying the Extract Method technique, we can separate the concerns and create a new method solely responsible for displaying info. public class Calculator
{
    public int Add(int a, int b)
    {
        DisplayOperationInfo(a, b);
        int sum = a + b;
        DisplaySum(sum);
        return sum;
    }

    private void DisplayOperationInfo(int a, int b)
    {
        // TODO: could we go even further and pass in
        // the operation string?!
        Console.WriteLine($"Adding {a} and {b}...");
    }

    private void DisplayResult(int result)
    {
        Console.WriteLine("The result is: " + result);
    }
} In this particular case, this technique is not helping us reduce the duplication of existing code (right now), but it is helping us bring some organization to the code. Given that this is a very trivial example, the real benefit of this is hard to observe — I mean, I added more code overall to make this happen. However, I’m trying to illustrate that we can conceptually group code into methods for better expression of what we’re trying to achieve. It’s just hard to show super simple examples of this! Benefits of Extract Method Using the Extract Method technique provides several benefits. Firstly, it improves the readability of our code by creating smaller, self-explanatory methods that focus on a single responsibility. This makes it easier for other developers to understand and maintain the code. This is what I tried to illustrate in the example code prior. Secondly, it promotes code reusability. By extracting a block of code into a separate method, we can easily reuse it in multiple places within our codebase. This reduces duplication and enforces the DRY (Don’t Repeat Yourself) principle. If we go to add other operators to our calculator, we could re-use the DisplayResult method and even refactor the DisplayOperationInfo method to pass in a parameter for which operation we’re performing! Scenarios Where Extract Method is Useful The Extract Method technique is particularly useful in scenarios where: A block of code within a method is becoming too long and complex – By extracting the code into a separate method, we can make the original method more concise and easier to understand. Common functionality needs to be reused across different methods – Extracting the common functionality into a separate method promotes code reuse and eliminates duplication. A method is responsible for multiple concerns – By extracting specific parts of the method into separate methods, we can improve the clarity and maintainability of the code. The Extract Method technique that once you start using, it almost becomes second nature in how you’re coding. By breaking down complex methods into smaller, focused ones, we can create code that is easier to understand and maintain. technique is a fundamental refactoring 2 – Rename Variables and Methods Clear and descriptive names are important in software engineering as they enhance code readability and maintainability. We spend so much of our time as programmers reading code that it’s critical we understand how to write expressive and concise code. When naming variables and methods, it’s important to choose names that accurately reflect their purpose and functionality. But guess what? Things change and evolve. The awesome name you picked today might not be so awesome 12 months from now when you’re trying to read your code and understand what the heck is going on. That’s cool because not only does it show you’re growing and improving, but because we have tools that can make it easy for us to make such changes. Importance of Clear and Descriptive Names Naming variables and methods with clear and descriptive names enables other developers to quickly understand their purpose and how they are used. This not only improves the readability of the code but also makes it easier to maintain and debug. Consider the following example: int x = 10;
int y = 5;
int z = x + y; In this code snippet, it is not immediately clear what the purpose of the variables , , and is. By renaming the variables to more descriptive names, we can make the code more self-explanatory: x y z int dollarsFromJack = 10;
int dollarsFromJill = 5;
int totalSpendingMoney = dollarsFromJack + dollarsFromJill; Now, it is clear that and represent the numbers being added, and represents their result — AND we get some context for why we’re using these numbers in the first place. dollarsFromJack dollarsFromJill totalSpendingMoney Using Visual Studio to Rename When renaming variables and methods, it is important to follow a consistent naming convention. In C#, the common practice is to use PascalCase for method names and camelCase for variable names. But what happens if you picked a crappy name? What happens if you forgot about the naming conventions and need to go update the usage of something in 100 spots? In Visual Studio, we have access to a rename refactoring shortcut. By default, this is F2 on your keyboard. Simply: Highlight your variable that you want to rename Press F2 Type in your new awesome name Press enter … Profit! You can repeat this for many things like classes, interfaces, method names… You name it! (pun intended?) Renaming things is one of the safest types of refactoring that we can do *IF* (and this is a REALLY BIG IF) you are renaming across all of the areas that are consuming your code. So for really small projects, especially if you don’t any types by name or heavily use reflection, you’re probably okay if there’s nobody consuming your library. But if you’re creating a public API or otherwise can’t update all of the consuming code paths at the same time you’re renaming – You’re probably going to break things. dynamically load ! I do earn money from this course, and this is an affiliate link should you choose to purchase other courses on Dometain. Thank you for your support! Click here to get this course Naming Conventions and Best Practices Naming conventions are going to come down to stylistic choices that may vary from team to team. However, there’s handful of general tenets that apply when considering how you name: Use descriptive names that accurately reflect the purpose of the variable or method. Avoid using single-character or ambiguous names, as they can make the code harder to understand. Consider using nouns for variables and verbs for methods to make their purpose clear. Avoid using reserved words or common language constructs as names. Consider reducing redundancy in your names. Remember to discuss with your team about what things they value in naming and what styles they adhere to. 3 – Extract Interface The Extract Interface refactoring technique is another thing that I rely on heavily in my own development. It involves creating an interface that defines a contract for a certain set of methods or properties, and then extracting that interface from existing code. This technique can help increase modularity, improve code reusability, and enhance testability. I generally start with the class itself so I can focus on what I’ll need passed in and what I can provide back out, which I find helps me come up with a better API contract for the interface. Let’s consider an example where we have a class called that performs various mathematical operations: Calculator public class Calculator
{
    public int Add(int a, int b)
    {
        return a + b;
    }

    public int Subtract(int a, int b)
    {
        return a - b;
    }

    public int Multiply(int a, int b)
    {
        return a * b;
    }

    public int Divide(int a, int b)
    {
        return a / b;
    }
} In this case, we can extract an interface, let’s call it , which will define the contract for these mathematical operations: ICalculator public interface ICalculator
{
    int Add(int a, int b);

    int Subtract(int a, int b);

    int Multiply(int a, int b);

    int Divide(int a, int b);
} Once we have the interface, we can modify our class to implement it: Calculator public class Calculator : ICalculator
{
    public int Add(int a, int b)
    {
        return a + b;
    }

    public int Subtract(int a, int b)
    {
        return a - b;
    }

    public int Multiply(int a, int b)
    {
        return a * b;
    }

    public int Divide(int a, int b)
    {
        return a / b;
    }
} Now, instead of directly using the class, we can program to the interface by using : Calculator ICalculator public void Calculate(ICalculator calculator)
{
    int result = calculator.Add(5, 3);
    // Do something with the result
} And yes – I know this is a trivial example and an interface for this is likely overkill. However, remember that calculator I included at the beginning of these examples? The one that writes to the console? Yeah, if you wanted to swap that out for one that wasn’t blowing up your console output then you could at least! But in all seriousness, this is just to illustrate to beginners that the interface defines an API and the class has the implementation. Advantages of Extracting Interfaces There are several advantages to using interfaces in software design and development: Promote loose coupling between components – By programming to an interface rather than a specific implementation, you can easily swap out different implementations without affecting the rest of the codebase. This promotes flexibility and extensibility. Code reusability – By defining a contract through an interface, you can create multiple classes that implement that interface. This allows for the reuse of code across different classes and reduces duplication. Improve testability – With interfaces, you can easily create mock objects or stubs for testing purposes. This makes it simpler to write unit tests and verify the behavior of your code in isolation. When should you use the Extract Interface technique? It’s particularly useful when you have multiple classes that share a common set of methods or properties. By extracting an interface, you can ensure consistency among these classes and simplify their usage. Of course, if you program like me, you potentially over-use interfaces. Sometimes there’s no real benefit to slapping an interface onto a class. Truly. I’m the kind of person who likes to mock any dependency when I unit test (I have other tests for real dependencies), and I *still* don’t think it makes sense to use an interface with everything. So use your judgement! 4 – Simplify Conditional Expressions When writing code, it’s important to have clear and concise conditional expressions. Complicated conditionals can lead to confusion and make code harder to read and maintain. When conditionals are too big, they’re hard to understand. When conditionals are too compact with poorly-named acronym or single-character variables, they’re hard to understand. So strike the right balance of verbosity to get your intention expressed clearly. Use the Ternary Operator: The ternary operator is a concise way to write simple conditional expressions. It has the form . By using the ternary operator, you can replace if-else statements with a single line of code. condition ? trueExpression : falseExpression Here’s an example: bool isEven = (number % 2 == 0) ? true : false; What’s not a fun time? Stacking multiple of these together. Try to avoid that. Extract Complex Conditions into Separate Boolean Variables: If you have complex conditions with multiple logical operators, it can be challenging to understand their meaning at a glance. To improve readability, consider extracting the conditions into separate boolean variables with descriptive names. Here’s an example: bool hasEnoughStock = (quantity > 0 && stockCount > 0);
bool isEligibleForDiscount = (customerAge >= 60 || isEmployee);
if (hasEnoughStock && isEligibleForDiscount)
{
    // Apply discount logic here
} This code is much easier to read than trying to put all four conditions directly into the if statement, especially because we get added context with clear variable names! Use the Null-Conditional Operator: The null-conditional operator ( ) is a handy feature introduced in C# 6.0. It allows you to safely access members of an object, even if the object itself is null. This operator can simplify the null-checking code by avoiding unnecessary statements. ?. if Here’s an example: // Will be null if 'text' is null
int? length = text?.Length; This one is good to discuss with your teams first. The shorthand here may not be obvious to folks, especially if they’re not used to this syntax in the code base. Wrapping Up Refactoring C# Code In this article, I’ve covered 4 important C# code techniques for refactoring Extract Method Rename Variables and Methods Extract Interface Simplify Conditional Expressions These techniques are important for software engineers looking to improve the readability, maintainability, and overall quality of their code. Remember, refactoring code is not just about improving the aesthetics, but about making it easier to work with and maintain in the long run. If you found this useful and you’re looking for more learning opportunities, consider and check out my ! subscribing to my free weekly software engineering newsletter free videos on YouTube Also published . here

4 Essential Techniques Simplified for Refactoring C# Code

Authors: (1) Alexander E.I. Brownlee, University of Stirling, UK; (2) James Callan, University College London, UK; (3) Karine Even-Mendoza, King’s College London, UK; (4) Alina Geiger, Johannes Gutenberg University Mainz, Germany; (5) Justyna Petke, University College London, UK; (6) Federica Sarro, University College London, UK; (7) Carol Hanna, University College London, UK; (8) Dominik Sobania, Johannes Gutenberg University Mainz, Germany. Table of Links Abstract & Introduction Experimental Setup Results Conclusions and Future Work Acknowledgements & References 3 Results The first experiment compares standard GI mutations, namely Insert and Statement edits, with LLM edits using differently detailed prompts (Simple, Medium, and Detailed) using Random Sampling. Table 1 shows results for all patches as well as for unique patches only. We report how many patches were successfully parsed by JavaParser (named as Valid), how many compiled, and how many passed all unit tests (named as Passed). We excluded patches syntactically equivalent to the original software. Best results are in bold. We see that although substantially more valid patches were found with the standard Insert and Statement edits, more passing patches could be found by using the LLM-generated edits. In particular, for the Medium, and Detailed prompts 292 and 230 patches passed the unit tests, respectively. For the Insert and Statement edits only 166 and 91 passed the unit tests, respectively. Anecdotally, the hot methods with lowest/highest patch pass rates differed for each operator: understanding this variation will be interesting for future investigation. It is also notable that LLM patches are less diverse: over 50% more unique patches were found by standard mutation operators than the LLM using Medium, Table 1. Results of our Random Sampling experiment. We exclude patches syntactically equivalent to the original software in this table. For all and unique patches we report: how many patches passed JavaParser, compiled, and passed all unit tests. Table 2. Local Search results. We exclude all empty patches. We report how many patches compiled, passed all unit tests, and how many led to improvements in runtime. We report best improvement found and median improvement among improving patches. and Detailed prompts. With the Simple prompt, however, not a single patch passed the unit tests, since the suggested edits often could not be parsed. Thus detailed prompts are necessary to force LLM to generate usable outputs. We investigated further the differences between Medium and Detailed prompts to understand the reduction in performance with Detailed (in the unique patches sets) as Medium had a higher number of compiled and passed patches. In both prompt levels, the generated response was the same for 42 cases (out of the total unique valid cases). However, Detailed tended to generate longer responses with an average of 363 characters, whereas Medium had an average of 304 characters. We manually examined several Detailed prompt responses, in which we identified some including variables from other files, potentially offering a significant expansion of the set of code variants GI can explore. The second experiment expands our analysis, comparing the performance of the standard and LLM edits with Local Search. Table 2 shows the results of the Local Search experiment. We report the number of compiling and passing patches as well as the number of patches were runtime improvements were found. Furthermore, we report the median and best improvement in milliseconds (ms). In the table, we excluded all empty patches. As before, best results are in bold. Again, we see that more patches passing the unit tests could be found with the LLM using the Medium, and Detailed prompts. In addition, more improvements could be found by using the LLM with these prompts. Specifically, with Medium and Detailed, we found 164 and 196 improvements, respectively, while we only found 136 with Insert and 71 with Statement. The best improvement could be found with 508 ms with the Statement edit. The best improvement found using LLMs (using the Medium prompt) was only able to improve the runtime by 395 ms. We also examined a series of edits in Local Search results to gain insights into the distinctions between Medium and Detailed prompts due to the low compilation rate of Detailed prompt’s responses. In the example, a sequence of edits aimed to inline a call to function clip. The Detailed prompt tried to incorporate the call almost immediately within a few edits, likely leading to invalid code. On the other hand, the Medium prompt made less radical changes, gradually refining the code. It began by replacing the ternary operator expression with an if-then-else statement and system function calls before eventually attempting to inline the clip function call. This paper is under CC 4.0 license. available on arxiv

Standard GI Mutations vs. LLM Edits in Random Sampling and Local Search

Hey there, have you ever needed to programmatically add a class to an element in an application? Like, maybe when a button is disabled, we need a class, but then once it’s enabled, we don’t. Or how about when a form goes from an invalid state to a valid one? Well, good news, this is actually pretty easy to do in angular. In this post, I’m going to show you four different ways. Angular First, we’ll use a method called class binding. Next, we’ll use the ngClass directive. After that, we’ll use the @HostBinding decorator. And finally, we’ll use the Renderer2 addClass() and removeClass() methods. Let’s get to it! https://youtu.be/sAa8QyFkVkI?embedable=true Using Angular Class Binding So class binding is something that you'd want to use in more simplistic cases where we just either want a class on an element or not. For example, we may want to add a disabled class to a button in a form when the form is invalid. To do this we simply add the word class in square brackets, followed by a dot and then our disabled class name. Then, we will bind this when our control is invalid. <form>
  ...
  <input [formControl]="emailControl" type="email" />
  ...
  <button [class.disabled]="emailControl.invalid">Subscribe</button>
</form> Using the Angular ngClass Directive When we encounter more complex scenarios, we may find ourselves needing to use the directive instead of Angular class binding. The directive gives us more flexibility and allows us to use more advanced logic for adding and removing class names. In this example, we want to switch between two different classes on our wrapping depending on whether the form is valid or not. ngClass fieldset To use the directive, we still use the square brackets, but this time we're going to use a ternary operator and when our control is invalid we'll add a class of 'invalid' and when it's not we'll add a class of 'valid'. ngClass <form>
  <fieldset [ngClass]="emailControl.invalid ? 'invalid' : 'valid'">
    ...
    <input [formControl]="emailControl" type="email" />
    ...
  </fieldset>
</form> Using Angular @HostBinding What if we need to conditionally bind a class on the host of our Angular Component or Directive? Well, this is where the Angular decorator comes into play. To do this we add the decorator within our component class and this will look much like our class binding example. We'll add the class name followed by a dot and then the class. Then we use a field, we'll call this one 'isValid' and we'll initialize it to false. @HostBinding @HostBinding To update this field, we'll need to subscribe to our email control status changes event and then simply update the value based on the status. ...
export class FormComponent implements OnInit {
  @HostBinding('class.valid') isValid = false;
  ...
  constructor(private destroyRef: DestroyRef) {}
    
  ngOnInit() {
    this.emailControl.statusChanges
      .pipe(takeUntilDestroyed(this.destroyRef))
      .subscribe((status) => this.isValid = status === 'VALID');
  }
} Using Angular Renderer2 addClass and removeClass Methods When we need to get really crazy and do something like add a class to the body element from within our component, this may seem near impossible in Angular. But, fortunately, it's not. We can reach for the Angular Renderer2 class which allows us to do several different things. For our purposes for conditionally adding classes to elements, we are only concerned with the add and remove class methods. First, we need to make sure that we inject the Renderer2 into our component via the constructor. Then, we will add a ternary operator within our status changes observable subscription for our control. If its status is valid, we will want to add the class to our element, and if it's invalid, we will want to be sure to remove the valid class. document.body ...
export class FormComponent implements OnInit {
  ...
  constructor(private destroyRef: DestroyRef, private renderer: Renderer2) {}
    
  ngOnInit() {
    this.emailControl.statusChanges
      .pipe(takeUntilDestroyed(this.destroyRef))
      .subscribe((status) => {
        ...
        status === 'VALID'
          ? this.renderer.addClass(document.body, 'valid')
          : this.renderer.removeClass(document.body, 'valid');
      });
  }
} In Conclusion Okay, so we now have four different ways to conditionally add and remove classes in Angular. First, we used class binding for more simple, straightforward cases. Then we used the directive where more advanced logic was needed. After that, we used the @HostBinding decorator to conditionally bind classes to our component host element. And finally, when all else failed and we needed something else, we used the Renderer2 add and remove class methods to bridge the gap. ngClass So hopefully that helps you out along your way and gives you some options when you need to programmatically add or remove classes. Want to See It in Action? Check out the demo code and examples of these techniques in the stackblitz example below. If you have any questions or thoughts, don’t hesitate to leave a comment. https://stackblitz.com/edit/stackblitz-starters-gn5o3d?ctl=1&embed=1&file=src%2Fform%2Fform.component.ts&embedable=true Also published here.

4 Ways to Dynamically Add Classes in Angular

This paper is available on arxiv under CC BY-NC-SA 4.0 DEED license. Authors: (1) Dihia LANASRI, OMDENA, New York, USA; (2) Juan OLANO, OMDENA, New York, USA; (3) Sifal KLIOUI, OMDENA, New York, USA; (4) Sin Liang Lee, OMDENA, New York, USA; (5) Lamia SEKKAI, OMDENA, New York, USA. Table of Links Abstract & Introduction Background Related Work Our Methodology Experiments and Results Conclusion, Acknowledgments & References 3 Related Work A restricted number of works have been published in the context of hate speech detection dealing with Arabic dialects. This section will analyze the most important NLP approaches dedicated to (1) the Algerian dialect and (2) Other Arabic dialects like Iraqi, Egyptian, Syrian, and Tunisian. This analysis helps us to identify the used approaches, models, and corpora. 3.1 Hate speech detection in Algerian dialect Guellil et al. [2022, 2021] Developed the first approach and corpus in Algerian dialect for hate speech detection against women in Arabic community on social media. This corpus contains more than 373K YouTube comments. Two different algorithms for feature extraction were used: Word2vec with machine learning models (GaussianNB, LogisticRegression, RandomForset, SGDClassifier, and LinearSVC) and FastText with Deep learning models (deep Convolutional Neural Network (CNN), long short-term memory (LSTM) network and Bi-directional LSTM (BiLSTM) network). Simulation results demonstrated the best performance of the CNN model with FastText. Boucherit and Abainia [2022] addressed the problem of detecting offensive and abusive content in Facebook comments. The corpus contains 8.7K comments in Algerian dialect written in Arabic and Latin characters, manually annotated as usual, abusive, and offensive. They used BiLSTM, CNN, FastText, SVM, and Multinomial Naive Bayes (NB) as classifiers. The experimental results showed that SVM and Multinomial NB classifiers outperformed all the other classifiers. Abainia et al. [2022] addressed the offensive language detection in the Amazigh language, which is one of the underresourced languages. They were interested in the Kabyle dialect. A new corpus of offensive Amazigh language is proposed containing 6.2K documents collected from Facebook and manually annotated as usual or offensive. A new lexicon of offensive and abusive Amazigh words with 12.6k entries is also developed. Many models have been evaluated, like SVM and Multinomial Naive Bayes classifiers tested with tf-idf. FastText was tested with deep learning models CNN and BiLSTM. The naive statistical classifier based on lexicon checking was the winner classifier. Mazari and Kheddar [2023] introduced a new dataset for Algerian dialect toxic text detection. An annotated multi-label dataset is built, containing around 14K comments extracted from Facebook, YouTube, and Twitter and labeled as hate speech, offensive language, and cyberbullying. Several tests have been conducted using many classification models of traditional machine learning: Random Forest, Naıve Bayes, Linear Support Vector (LSV), Stochastic Gradient Descent (SGD), and Logistic Regression. Furthermore, several assessments have been conducted using Deep Learning models such as CNN, LSTM, Gated Recurrent Unit (GRU), BiLSTM and Bidirectional-GRU (Bi-GRU). Results demonstrated the best performance of LSV, BiLSTM, and MLP when associated with the SGD model. Guellil et al. [2020] proposed a system for detecting hateful speech in Arabic political debates. The approach was evaluated against a hateful corpus concerning Algerian political debates. It contains 5K YouTube comments in MSA and Algerian dialects, written in both Arabic and Latin characters. Both classical algorithms of classification (Gaussian NB, Logistic Regression, Random Forest, SGD Classifier, and Linear SVC(LSVC)) and deep learning algorithms (CNN, multilayer perceptron (MLP), LSTM, and BiLSTM) are tested. For extracting features, the authors use Word2vec and FastText with their two implementations, namely, Skip Gram and CBOW. Simulation results demonstrate the best performance of LSVC, BiLSTM and MLP. Mohdeb et al. [2022] proposed an approach for analysis and the detection of dialectal Arabic hate speech that targeted African refugees and illegal migrants on the YouTube Algerian space. The corpus contains more than 4K comments annotated as Incitement, Hate, Refusing with non-hateful words, Sympathetic, and Comment. The transfer learning approach has been exploited for classification. The experiments show that the AraBERT monolingual transformer outperforms the mono-dialectal transformer DziriBERT and the cross-lingual transformers mBERT and XLM-R. 3.2 Hate speech detection in other Arabic dialects Various datasets or corpora were published in different dialects, which can be used for different purposes like hate speech, racism, violence, etc. detection. ALBayari and Abdallah [2022] is the first work to propose a corpus built from Instagram comments. This corpus contains 198K comments, written in MSA and three different dialects: Egyptian, Gulf, and Levantine. The comments were annotated as neutral, toxic, and Bullying. Al-Ajlan and Ykhlef [2018] and Haidar et al. [2019] datasets are collected from Twitter containing respectively 20K and 34K multi-dialectal Arabic tweets annotated as bullying and non-bullying labels. These tweets were from various dialects (Lebanon, Egypt, and the Gulf area). Moreover, two other datasets were proposed by Mubarak et al. [2017]. The first one with 1.1K tweets in different dialects and the second dataset contains 32K inappropriate comments collected from a famous Arabic news site and annotated as obscene, offensive, or clean. Albadi et al. [2018] proposed the religious hate speech detection where a multi-dialectal dataset of 6.6K tweets was introduced. It included an identification of the religious groups targeted by hate speech. Alakrot et al. [2018] also provided a dataset of 16K Egyptian, Iraqi, and Libyan comments collected from YouTube. The comments were annotated as either offensive, inoffensive, or neutral. T-HSAB Haddad et al. [2019] and L-HSAB Mulki et al. [2019] are two publicly available corpora for abusive hate speech detection. The first one is in the Tunisian dialect, combining 6K comments. The second one is in Levantine dialect (Syrian, Lebanese, Palestinian, and Jordanian dialects) containing around 6K tweets. These documents are labeled as Abusive, Hate, or Normal. Mubarak et al. [2020] looked at MSA and four major dialects (Egyptian, Levantine, Maghrebi, and Gulf). It presented a systematic method for building an Arabic offensive language tweet dataset that does not favor specific dialects, topics, or genres with 10K tweets. For tweet labeling, they used the count of positive and negative terms based on a polarity lexicon. FastText and Skip-Gram (AraVec skip-gram, Mazajak skip-gram); and deep contextual embeddings, namely BERTbase-multilingual and AraBERT are used. They evaluated different models: SVM, AdaBoost, and Logistic regression. Mulki and Ghanem [2021] introduced the first Arabic Levantine Twitter dataset for Misogynistic language (LeT-Mi) to be a benchmark dataset for automatic detection of online misogyny written in the Arabic and Levantine dialect. The proposed dataset consists of 6.5K tweets annotated either as neutral (misogynistic-free) or as one of seven misogyny categories: discredit, dominance, cursing/damning, sexual harassment, stereotyping and objectification, derailing, and threat of violence. They used BOW + TF-IDF, SOTA, LSTM, BERT, and Majority class as classifiers. Duwairi et al. [2021] investigated the ability of CNN, CNN-LSTM, and BiLSTM-CNN deep learning networks to classify or discover hateful content posted on social media. These deep networks were trained and tested using the ArHS dataset, which consists of around 10K tweets that were annotated to suit hateful speech detection in Arabic. Three types of experiments are reported: first, the binary classification of tweets into Hate or Normal. Ternary classification of tweets into (Hate, Abusive, or Normal), and multi-class classification of tweets into (Misogyny, Racism, Religious Discrimination, Abusive, and Normal). Aldjanabi et al. [2021] have built an offensive and hate speech detection system using a multi-task learning (MTL) model built on top of a pre-trained Arabic language model. The Arabic MTL model was experimented with two different language models to cover MSA and dialect Arabic. They evaluated a new pre-trained model ’MarBERT’ to classify both dialect and MSA tweets. They propose a model to explore multi-corpus-based learning using Arabic LMs and MTL to improve the classification performance. Haidar et al. [2017] presented a solution for the issue of cyberbullying in both Arabic and English languages. The proposed solution is based on machine learning algorithms using a dataset from Lebanon, Syria, the Gulf Area, and Egypt. That dataset contained 35K Arabic texts. In this research, Naïve Bayes and SVM models were chosen to classify the text. The SVM model achieved greater precision. Abdelali et al. [2016] The authors built a large dataset that consists of offensive Arabic words from different dialects and topics. The tweets were labeled into one of these categories: offensive, vulgar, hate speech, or clean. Since the offensive tweets involve implicit insults, the hate speech category was the tweets that contain racism, religious, and ethnic words. Different classifiers were employed in this study; the SVM model with a radial function kernel was mainly used with lexical features and pre-trained static embedding, while Adaptive Boosting and Logistic regression classifiers were employed when using Mazajak embedding. SVM gave the best precision. According to this literature analysis, we detect that the topic of hate speech detection in the Algerian dialect is not widely considered, and only few works deal with this problem. Furthermore, a lack of Algerian datasets prepared for hate speech is found. All these findings motivate our proposal.

Hate Speech Detection in Algerian Dialect Using Deep Learning: Related Work

Authors: (1) Alexander E.I. Brownlee, University of Stirling, UK; (2) James Callan, University College London, UK; (3) Karine Even-Mendoza, King’s College London, UK; (4) Alina Geiger, Johannes Gutenberg University Mainz, Germany; (5) Carol Hanna, University College London, UK; (6) Justyna Petke, University College London, UK; (7) Federica Sarro, University College London, UK; (8) Dominik Sobania, Johannes Gutenberg University Mainz, Germany. Content Overview Abstract Introduction Experimental Setup Results Conclusions and Future Work References Abstract Large language models (LLMs) have been successfully applied to software engineering tasks, including program repair. However, their application in search-based techniques such as Genetic Improvement (GI) is still largely unexplored. In this paper, we evaluate the use of LLMs as mutation operators for GI to improve the search process. We expand the Gin Java GI toolkit to call OpenAI’s API to generate edits for the JCodec tool. We randomly sample the space of edits using 5 different edit types. We find that the number of patches passing unit tests is up to 75% higher with LLM-based edits than with standard Insert edits. Further, we observe that the patches found with LLMs are generally less diverse compared to standard edits. We ran GI with local search to find runtime improvements. Although many improving patches are found by LLM-enhanced GI, the best improving patch was found by standard GI. Introduction As software systems grow larger and more complex, significant manual effort is required to maintain them [2]. To reduce developer effort in software maintenance and optimization tasks, automated paradigms are essential. Genetic Improvement (GI) [15] applies search-based techniques to improve non-functional properties of existing software such as execution time as well as functional properties like repairing bugs. Although GI has had success in industry [12,13], it remains limited by the set of mutation operators it employs in the search [14]. Large Language Models (LLMs) have a wide range of applications as they are able to process textual queries without additional training for the particular task at hand. LLMs have been pre-trained on millions of code repositories spanning many different programming languages [5]. Their use for software engineering tasks has had great success [9,6], showing promise also for program repair [17,19]. Kang and Yoo [10] have suggested that there is untapped potential in using LLMs to enhance GI. GI uses the same mutation operators for different optimization tasks. These operators are hand-crafted prior to starting the search and thus result in a limited search space. We hypothesize that augmenting LLM patch suggestions as an additional mutation operator will enrich the search space and result in more successful variants. In this paper, we conduct several experiments to explore whether using LLMs as a mutation operator in GI can improve the efficiency and efficacy of the search. Our results show that the LLM-generated patches have compilation rates of 51.32% and 53.54% for random search and local search, respectively (with the Medium prompt category). Previously LLMs (using an LLM model as-is) were shown to produce code that compiled roughly 40% of the time [16,18]. We find that randomly sampled LLM-based edits compiled and passed unit tests more often compared to standard GI edits. We observe that the number of patches passing unit tests is up to 75% higher for LLM-based edits than GI Insert edits. However, we observe that patches found with LLMs are less diverse. For local search, the best improvement is achieved using standard GI Statement edits, followed by LLM-based edits. These findings demonstrate the potential of LLMs as mutation operators and highlight the need for further research in this area. Experimental Setup To analyze the use of LLMs as a mutation operator in GI, we used the GPT 3.5 Turbo model by OpenAI and the GI toolbox Gin [3]. We experimented with two types of search implemented within Gin: random search and local search. Requests to the LLM using the OpenAI API were via the Langchain4J library, with a temperature of 0.7. The target project for improvement in our experiments was the popular JCodec [7] project which is written in Java. ‘Hot’ methods to be targeted by the edits were identified using Gin’s profiler tool by repeating the profiling 20 times and taking the union of the resulting set. For the random sampling experiments, we set up the runs with statement level edits (copy/delete/replace/swap from [14] and insert break/continue/return from [4]) and LLM edits, generating 1000 of each type at random. A timeout of 10000 milliseconds was used for each unit test to catch infinite loops introduced by edits; exceeding the timeout counts as a test failure. For local search, experiments were set up similarly. There were 10 repeat runs (one for each of the top 10 hot methods) but the runs were limited to 100 evaluations resulting in 1000 evaluations in total, matching the random search. In practice this was 99 edits per run as the first was used to time the original unpatched code. We experimented with three different prompts for sending requests to the LLM for both types of search: a simple prompt, a medium prompt, and a detailed prompt. With all three prompts, our implementation requests five different variations of the code at hand. The simple prompt only requests the code without any additional information. The medium prompt provides more information about the code provided and the requirements, as shown in Figure 1. Specifically, we provide the LLM with the programming language used, the project that the code belongs to, as well as formatting instructions. The detailed prompt extends the medium prompt with an example of a useful change. This example was taken from results obtained by Brownlee et al. [4]. The patch is a successful instance of the insert edit applied to the jCodec project (i.e., an edit that compiled, passed the unit tests and offered a speedup over the original code). We use the same example for all the detailed prompt requests used in our experiments; this is because LLMs are capable of inductive reasoning where the user presents specific information, and the LLM can use that input to generate more general statements, further improved in GPT-4 [8]. LLM edits are applied by selecting a block statement at random in a target ‘hot’ method. This block’s content is in the prompt. The first code block in the LLM response is identified. Gin uses JavaParser (https://javaparser.org) internally to represent target source files, so we attempt to parse the LLM suggestion with JavaParser, and replace the original block with the LLM suggestion. Results The first experiment compares standard GI mutations, namely Insert and Statement edits, with LLM edits using differently detailed prompts (Simple, Medium, and Detailed) using Random Sampling. Table 1 shows results for all patches as well as for unique patches only. We report how many patches were successfully parsed by JavaParser (named as Valid), how many compiled, and how many passed all unit tests (named as Passed). We excluded patches syntactically equivalent to the original software. Best results are in . bold We see that although substantially more valid patches were found with the standard Insert and Statement edits, more passing patches could be found by using the LLM-generated edits. In particular, for the Medium, and Detailed prompts 292 and 230 patches passed the unit tests, respectively. For the Insert and Statement edits only 166 and 91 passed the unit tests, respectively. Anecdotally, the hot methods with lowest/highest patch pass rates differed for each operator: understanding this variation will be interesting for future investigation. It is also notable that LLM patches are less diverse: over 50% more unique patches were found by standard mutation operators than the LLM using Medium, and Detailed prompts. With the Simple prompt, however, not a single patch passed the unit tests, since the suggested edits often could not be parsed. Thus detailed prompts are necessary to force LLM to generate usable outputs. We investigated further the differences between Medium and Detailed prompts to understand the reduction in performance with Detailed (in the unique patches sets) as Medium had a higher number of compiled and passed patches. In both prompt levels, the generated response was the same for 42 cases (out of the total unique valid cases). However, Detailed tended to generate longer responses with an average of 363 characters, whereas Medium had an average of 304 characters. We manually examined several Detailed prompt responses, in which we identified some including variables from other files, potentially offering a significant expansion of the set of code variants GI can explore. The second experiment expands our analysis, comparing the performance of the standard and LLM edits with Local Search. Table 2 shows the results of the Local Search experiment. We report the number of compiling and passing patches as well as the number of patches were runtime improvements were found. Furthermore, we report the median and best improvement in milliseconds (ms). In the table, we excluded all empty patches. As before, best results are in . bold Again, we see that more patches passing the unit tests could be found with the LLM using the Medium, and Detailed prompts. In addition, more improvements could be found by using the LLM with these prompts. Specifically, with Medium and Detailed, we found 164 and 196 improvements, respectively, while we only found 136 with Insert and 71 with Statement. The best improvement could be found with 508 ms with the Statement edit. The best improvement found using LLMs (using the Medium prompt) was only able to improve the runtime by 395 ms. We also examined a series of edits in Local Search results to gain insights into the distinctions between Medium and Detailed prompts due to the low compilation rate of Detailed prompt’s responses. In the example, a sequence of edits aimed to inline a call to function clip. The Detailed prompt tried to incorporate the call almost immediately within a few edits, likely leading to invalid code. On the other hand, the Medium prompt made less radical changes, gradually refining the code. It began by replacing the ternary operator expression with an if-then-else statement and system function calls before eventually attempting to inline the clip function call. Conclusions and Future Work Genetic improvement of software is highly dependent on the mutation operators it utilizes in the search process. To diversify the operators and enrich the search space further, we incorporated a Large Language Model (LLM) as an operator. . To generalise, future work should consider projects besides our target, jCodec. Our experiments used an API giving us no control over the responses generated by the LLM or any way of modifying or optimizing them. Though we did not observe changes in behaviour during our experiments, OpenAI may change the model at any time, so future work should consider local models. We experimented with only three prompt types for LLM requests and within this limited number of prompts found a variation in the results. Finally, our implementation for parsing the responses from the LLMs was relatively simplistic. However, this would only mean that our reported results are pessimistic and an even larger improvement might be achieved by the LLM-based operator. Limitations . We found that, although more valid and diverse patches were found with standard edits using Random Sampling, more patches passing the unit tests were found with LLM-based edits. For example, with the LLM edit using the Medium prompt, we found over 75% more patches passing the unit tests than with the classic Insert edit. In our Local Search experiment, we found the best improvement with the Statement edit (508 ms). The best LLMbased improvement was found with the Medium prompt (395 ms). Thus there is potential in exploring approaches combining both LLM and ‘classic’ GI edits. Summary Our experiments revealed that the prompts used for LLM requests greatly affect the results. Thus, in future work, we hope to experiment more with prompt engineering. It might also be helpful to mix prompts: e.g., starting with medium then switching to detailed to make larger edits that break out of local minima. Further, the possibility of combining LLM edits with others such as standard copy/delete/replace/swap or PAR templates [11] could be interesting. Finally, we hope to conduct more extensive experimentation on additional test programs. The code, LLMs prompt and experimental infrastructure, data from the evaluation, and results are available as open source at [1]. The code is also under the ‘llm’ branch of github.com/gintool/gin (commit 9fe9bdf; branched from master commit 2359f57 pending full integration with Gin). Data Availability. UKRI EPSRC EP/P023991/1 and ERC 741278. Acknowledgements References Artifact of Enhancing Genetic Improvement Mutations Using Large Language Models. Zenodo (Sep 2023). https://doi.org/10.5281/zenodo.8304433 B¨ohme, M., Soremekun, E.O., Chattopadhyay, S., Ugherughe, E., Zeller, A.: Where is the bug and how is it fixed? An experiment with practitioners. In: Proc. ACM Symposium on the Foundations of Software Engineering. pp. 117–128 (2017) Brownlee, A.E., Petke, J., Alexander, B., Barr, E.T., Wagner, M., White, D.R.: Gin: genetic improvement research made easy. In: GECCO. pp. 985–993 (2019) Brownlee, A.E., Petke, J., Rasburn, A.F.: Injecting shortcuts for faster running Java code. In: IEEE CEC 2020. p. 1–8 Chen, M., Tworek, J., Jun, H., Yuan, Q., Pinto, H.P.d.O., Kaplan, J., Edwards, H., Burda, Y., Joseph, N., Brockman, G., et al.: Evaluating large language models trained on code. arXiv preprint arXiv:2107.03374 (2021) Fan, A., Gokkaya, B., Harman, M., Lyubarskiy, M., Sengupta, S., Yoo, S., Zhang, J.M.: Large language models for software engineering: Survey and open problems (2023) Github - jcodec/jcodec: Jcodec main repo, https://github.com/jcodec/jcodec Han, S.J., Ransom, K.J., Perfors, A., Kemp, C.: Inductive reasoning in humans and large language models. Cognitive Systems Research p. 101155 (2023) Hou, X., Liu, Y., Yang, Z., Grundy, J., Zhao, Y., Li, L., Wang, K., Luo, X., Lo, D., Wang, H.: Large language models for software engineering: A systematic literature review. arXiv:2308.10620 (2023) Kang, S., Yoo, S.: Towards objective-tailored genetic improvement through large language models. arXiv:2304.09386 (2023) Kim, D., Nam, J., Song, J., Kim, S.: Automatic Patch Generation Learned from Human-Written Patches (2013), http://logging.apache.org/log4j/ Kirbas, S., Windels, E., Mcbello, O., Kells, K., Pagano, M., Szalanski, R., Nowack, V., Winter, E., Counsell, S., Bowes, D., Hall, T., Haraldsson, S., Woodward, J.: On the introduction of automatic program repair in bloomberg. IEEE Software 38(4), 43–51 (2021) Marginean, A., Bader, J., Chandra, S., Harman, M., Jia, Y., Mao, K., Mols, A., Scott, A.: Sapfix: Automated end-to-end repair at scale. In: ICSE-SEIP. pp. 269– 278 (2019) Petke, J., Alexander, B., Barr, E.T., Brownlee, A.E., Wagner, M., White, D.R.: Program transformation landscapes for automated program modification using Gin. Empirical Software Engineering 28(4), 1–41 (2023) Petke, J., Haraldsson, S.O., Harman, M., Langdon, W.B., White, D.R., Woodward, J.R.: Genetic improvement of software: A comprehensive survey. IEEE Transactions on Evolutionary Computation 22, 415–432 (2018) Siddiq, M.L., Santos, J., Tanvir, R.H., Ulfat, N., Rifat, F.A., Lopes, V.C.: Exploring the effectiveness of large language models in generating unit tests. arXiv preprint arXiv:2305.00418 (2023) Sobania, D., Briesch, M., Hanna, C., Petke, J.: An analysis of the automatic bug fixing performance of chatgpt. In: 2023 IEEE/ACM International Workshop on Automated Program Repair (APR). pp. 23–30. IEEE Computer Society (2023) Xia, C.S., Paltenghi, M., Tian, J.L., Pradel, M., Zhang, L.: Universal fuzzing via large language models. arXiv preprint arXiv:2308.04748 (2023) Xia, C.S., Zhang, L.: Keep the conversation going: Fixing 162 out of 337 bugs for $0.42 each using chatgpt. arXiv preprint arXiv:2304.00385 (2023) This paper is under CC 4.0 license. available on arxiv

Enhancing Genetic Improvement Mutations Using Large Language Models

বড় ভাষার মডেল ব্যবহার করে জেনেটিক উন্নতির মিউটেশন বৃদ্ধি করা

Verbesserung genetischer Verbesserungsmutationen mithilfe großer Sprachmodelle

Mejora de las mutaciones de mejora genética mediante modelos de lenguaje grandes

Améliorer les mutations d'amélioration génétique à l'aide de grands modèles de langage

बड़े भाषा मॉडल का उपयोग करके आनुवंशिक सुधार उत्परिवर्तन को बढ़ाना

大規模言語モデルを使用した遺伝子改良突然変異の強化

대규모 언어 모델을 사용하여 유전적 개선 돌연변이 강화

Aprimorando mutações de melhoria genética usando grandes modelos de linguagem

Усиление мутаций генетического улучшения с использованием больших языковых моделей

Büyük Dil Modelleri Kullanılarak Genetik İyileştirme Mutasyonlarının Geliştirilmesi

Tăng cường đột biến cải thiện di truyền bằng mô hình ngôn ngữ lớn

使用大型语言模型增强遗传改良突变

is a very important but often misunderstood method in React. In this guide, we’ll try to shed light on what is, what it does, and why it’s so important for the development process with React. render() render() What is render in React? Render method returns the component structure written in JSX. In other words, it defines what the user interface should look like. React components re-render whenever there’s a change to state or props to make sure the latest changes are reflected on the page. Automatically updating (re-rendering) to display the latest changes is a key feature of React. It is what allows Facebook to display new notifications and comments without reloading the page. Let’s take a closer look at what exactly render() method does. My blog also explores a number of specific use cases, like rendering when the user clicks a button. SimpleFrontEnd How method works render() You’ve probably noticed that in-class components, method returns HTML-like code to define component layout. Functional components do not have an explicit method, but functions themselves work the same. render() render() Reacting to changes is very important in React. That’s why every component has a method.  React calls method to update the component’s (and all of its children’s) layout to make sure it’s in line with the latest changes. render() render() Next, let’s talk about what gets rendered. method renders a virtual DOM, not the actual DOM that we see in the browser. Virtual DOM is another very important feature in React. It’s essentially a lightweight copy of the real DOM, so React can efficiently render and re-render it to make sure the app stays up to date. render() Once updates the virtual DOM, and React notices differences between the virtual DOM and the real DOM. The library automatically updates the HTML to reflect the latest changes. All of this happens automatically, without any input from developers. render() method runs every time there’s a change to state or props. Any side effects in the function body are going to run as well. Important: render() Conditional rendering in React React is a JavaScript library, so you can use dynamic expressions to render (or not render) elements and components. You can also embed JavaScript expressions inside the component layout via JSX. If/else statement allows you to conditionally customize the component’s layout. As you can see in this , the heading ‘Hello World’ renders because the condition is met. CodeSandbox Most components return multiple components and/or elements. React has an important rule – components must always return one element, so don’t forget to wrap multiple elements with a div or a fragment. Important: React also allows us to embed ternary operators inside JSX. So we can conditionally render components right in the layout. These are basic examples. In the real world, conditions usually come from the state, and values are likely to change in response to users’ actions.

A Quick Guide To The render() Method in React

When developing web applications, marking menu items, tabs, or other parts of the user interface, as active is a common need. In the , doing this quickly might lead you to something like this: Phoenix Framework <.link
  href={~p"/stores/#{@store}/products"}
  class={"tab" <> if @active == :products, do: " tab-active", else: ""}
>
  Products
</.link> In this approach, we use ternary expressions and string concatenation to conditionally define CSS classes. It works, but as conditional logic increases, it can become challenging to read and maintain. Introducing Short-circuit Evaluation In Elixir, and are often used interchangeably. However, there’s a slight difference. Lazy evaluation is usually associated with more complex data structures, while short-circuit is . And that’s what we’re going to use. lazy evaluation short-circuit evaluation more common in boolean expressions Let’s look at some examples using : iex list = ["plataformatec", nil, "sourcelevel", false, "dashbit"]
#=> ["plataformatec", nil, "sourcelevel", false, "dashbit"]

# Using short-circuit evaluation on the list
list = ["plataformatec", nil && "sourcelevel", false && "dashbit"]
#=> ["plataformatec", nil, false] In the second definition of the list, we are using a short-circuit operation, where the last value of the expression prevails when the previous one is true; otherwise, the previous value is retained. In simple terms, it’s like telling : “Stop thinking as soon as you know the answer.” Elixir Applying Short-circuit to the CSS Class List In , an approach using lazy evaluation for the class syntax was discussed. , it was clarified that if the list item is or , it will be removed. Phoenix Framework issue #276 In this comment false nil We can apply this solution to our example: <.link
  href={~p"/stores/#{@store}/products"}
  class={["tab", @active == :products && "tab-active"]}
>
  Products
</.link> If is , the string will be added to the list (resulting in ), otherwise, it will be omitted (resulting in just ). This approach is cleaner, more readable, and efficient: @active :products "tab-active" tab tab-active tab : The lazy evaluation syntax is more concise, resulting in cleaner code. Code Conciseness : Lazy evaluation halts evaluation as soon as the result is known, avoiding unnecessary evaluations. Efficiency : The class list is easy to understand and maintain, improving code readability. Readability : The simplified syntax makes code maintenance easier over time. Ease of Maintenance When developing applications in Elixir, it’s not just about using the functional paradigm, but also about writing concise and easily understandable code. This approach not only simplifies our code but also makes maintenance more straightforward and direct. 😎✨ Also published here Photo by Elena Mozhvilo on Unsplash

How to Define an Active Menu Item in a Phoenix Framework Through Short-Circuit Evaluation

148 Stories To Learn About Php

Your code smells because there are likely many instances where it could be edited or improved. Most of these smells are just hints of something that might be wrong. Therefore, they are not required to be fixed per se… (You should look into it, though.) Previous Code Smells You can find all the previous code smells (Part i - ) . XLI here Let's continue... Code Smell 206 - Long Ternaries You love ternaries too much TL;DR: Don't use ternaries for code execution. You should read them as a math formula. Problems Difficult to read Low Reuse Low Testability Solutions Extract the method guards Refactorings Refactoring 010 - Extract Method Object Context When a ternary condition is used in code that contains multiple functions, it can be challenging to determine which function is being affected by the condition. This can make it harder to identify and fix bugs, as well as to understand how the code works in general. Sample Code Wrong const invoice = isCreditCard ? 
  prepareInvoice();
  fillItems();
  validateCreditCard();
  addCreditCardTax();
  fillCustomerDataWithCreditCard();
  createCreditCardInvoice() 
:
  prepareInvoice();
  fillItems();
  addCashDiscount();
  createCashInvoice();

// The intermediate results are not considered
// The value of the invoice is the result of
// the last execution Right const invoice = isCreditCard ? 
                    createCreditCardInvoice() :
                    createCashInvoice();

// or better... 

if (isCreditCard) {
  const invoice = createCreditCardInvoice();
} else {
  const invoice = createCashInvoice();
}

// Even better with polymorphism...

const invoice = paymentMethod.createInvoice(); Detection Automatic [x] Linters can detect large code blocks Tags Bloaters Conclusion No matter where you have long lines of code, you can always refactor into higher-level functional and shorter methods. Relations Code Smell 03 - Functions Are Too Long More Info https://hackernoon.com/how-to-get-rid-of-annoying-ifs-forever-zuh3zlo?embedable=true Disclaimer Code Smells are my . opinion Credits Photo by on Jens Lelie Unsplash Thanks, Cory Twitter The programs that live best and longest are those with short functions. You learn just how valuable all those little functions are. All of the payoffs of indirection—explanation, sharing, and choosing—are supported by small functions. Martin Fowler https://hackernoon.com/400-thought-provoking-software-engineering-quotes?embedable=true This article is part of the CodeSmell Series. https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-i-xqz3evd?embedable=true Code Smell 207 - Dynamic Methods Metaprogramming is fancy. but it is not free TL;DR: Don't add dynamic behavior with metaprogramming Problems Readability Maintainability Harder to debug (The code is generated dynamically at runtime) Security Issues (if the configuration file is not properly ) sanitized Single Responsibility Principle violation (mixing the concerns of model definition and configuration). Solutions Define the methods by hand Use the Decorator design pattern Context is a powerful technique that allows you to write code that can generate, modify, or analyze other code at runtime. However, it can also lead to code that is difficult to understand, maintain, and debug. Metaprogramming Sample Code Wrong class Skynet < ActiveRecord::Base
  # dynamically add some attributes based on a configuration file
  YAML.load_file("attributes.yml")["attributes"].each do |attribute|
    attr_accessor attribute
  end
  
  # define some dynamic methods based on a configuration file
  YAML.load_file("protocol.yml")["methods"].each do |method_name, method_body|
    define_method method_name do
      eval method_body
    end
  end
end Right class Skynet < ActiveRecord::Base
  # define some attributes explicitly
  attr_accessor :asimovsFirstLaw, :asimovsSecondLaw, :asimovsThirdLaw
  
  # define some methods explicitly
  def takeoverTheWorld
    # implementation
  end    
end Detection Automatic [x] We have a whitelist of valid usages or directly ban some methods. Tags Meta-Programming Conclusion Metaprogramming often involves using complex code and abstractions that can make the resulting code difficult to read and maintain. This can make it harder for other developers to understand and modify the code in the future, leading to increased complexity and bugs. Relations Code Smell 21 - Anonymous Functions Abusers Code Smell 189 - Not Sanitized Input More Info https://hackernoon.com/laziness-chapter-i-meta-programming-6s4l300e?embedable=true Credits Photo by on Brett Jordan Unsplash A year spent in artificial intelligence is enough to make one believe in God. Alan Perlis Code Smell 208 - Null Island You can avoid null if you try TL;DR: Don't use null for real places Problems Coupling Unexpected Results Solutions Model the unknown location with polymorphism Context is a fictional place, which is located at the coordinates , at the intersection of the Prime Meridian and the Equator in the Atlantic Ocean. Null Island 0°N 0°E The name "Null Island" comes from the fact that this location represents the point where a lot of GPS systems place any data that has missing or invalid location coordinates. In reality, there is no landmass at this location, and it is actually in the middle of the ocean. This point has become a popular reference for geographic information systems (GIS) and mapping software, as it serves as a way to filter out errors in location data. Sample Code Wrong class Person(val name: String, val latitude: Double, val longitude: Double)

fun main() {
    val people = listOf(
        Person("Alice", 40.7128, -74.0060), // New York City
        Person("Bob", 51.5074, -0.1278), // London
        Person("Charlie", 48.8566, 2.3522), // Paris
        Person("Tony Hoare", 0.0, 0.0) // Null Island
    )
    
    for (person in people) {
        if (person.latitude == 0.0 && person.longitude == 0.0) {
            println("${person.name} lives on Null Island!")
        } else {
            println("${person.name} lives at (${person.latitude}, ${person.longitude}).")
        }
    }
} Right abstract class Location {
    abstract fun calculateDistance(other: Location): Double
}

class Coordinates(val latitude: Double, val longitude: Double) : Location() {
    override fun calculateDistance(other: Location): Double {    
        val earthRadius = 6371.0 // kilometers
        val latDistance = Math.toRadians(latitude - other.latitude)
        val lngDistance = Math.toRadians(longitude - other.longitude)
        val a = sin(latDistance / 2) * sin(latDistance / 2) +
                cos(Math.toRadians(latitude)) * cos(Math.toRadians(other.latitude)) *
                sin(lngDistance / 2) * sin(lngDistance / 2)
        val c = 2 * atan2(sqrt(a), sqrt(1 - a))
        return earthRadius * c
    }
}

class UnknownLocation : Location() {
    override fun calculateDistance(other: Location): Double {
        throw IllegalArgumentException("Cannot calculate distance from unknown location.")
    }
}

class Person(val name: String, val location: Location)

fun main() {
    val people = listOf(
        Person("Alice", Coordinates(40.7128, -74.0060)), // New York City
        Person("Bob", Coordinates(51.5074, -0.1278)), // London
        Person("Charlie", Coordinates(48.8566, 2.3522)), // Paris
        Person("Tony Hoare", UnknownLocation()) // Unknown location
    )
    
    val rio = Coordinates(-22.9068, -43.1729) // Rio de Janeiro coordinates
    
    for (person in people) {
        try {
            val distance = person.location.calculateDistance(rio)
            println("${person.name} is ${distance} kilometers from Rio de Janeiro.")
        } catch (e: IllegalArgumentException) {
            println("${person.name} is at an unknown location.")
        }
    }
} Detection Semi-Automatic [x] We can check for special numbers used as nulls Tags Null Conclusion Don't use to represent Null real objects Relations Code Smell 12 - Null Code Smell 126 - Fake Null Object Code Smell 160 - Invalid Id = 9999 More Info Null: The Billion Dollar Mistake Wikipedia The billion dollar mistake of having null in the language. And since JavaScript has both null and undefined, it's the two billion dollar mistake. Anders Hejlsberg Code Smell 209 - Side Effects Global scope is easy or a nightmare, or both TL;DR: Avoid side effects on your code. Problems Coupling Least Astonishment Principle violation Solutions Favor referential transparency Context Referential transparency always produces the same output for a given input and does not have any side effects, such as modifying global variables or performing I/O operations. A function or expression is referentially transparent if it can be replaced with its evaluated result without changing the behavior of the program. This property allows for easier reasoning about the behavior of a program and enables optimizations such as caching and memorization. Functions are treated as mathematical expressions that map inputs to outputs. Sample Code Wrong let counter = 0;

function incrementCounter(value: number): void {
  // Two side effects
  
  counter += value; 
  // it modifies the global variable counter 
  
  console.log(`Counter is now ${counter}`); 
  // it logs a message to the console.
} Right function incrementCounter(counter: number, value: number): number {  
  return counter + value; 
  // Not too efficient  
} Detection Automatic [x] Most linterns can warn you when accessing the global state or and create side effects. Functions Tags Global Conclusion Functional Programming is amazing and can teach us a lot about how to write clean code. We need to understand its pillars. Relations Code Smell 17 - Global Functions Disclaimer Code Smells are my . opinion Credits Photo by on Daan Mooij Unsplash The most effective debugging tool is still careful thought, coupled with judiciously placed print statements. Brian W. Kernighan Code Smell 210 - Dynamic Properties Laziness and magic bring defects TL;DR: Be explicit with your attributes Problems Readability Scope definition Unnoticed typos Solutions Favor languages forbidding dynamic properties Context Dynamic properties break type safety since it's easy to introduce typos or use the wrong property names accidentally. This can lead to runtime errors that can be difficult to debug, especially in larger codebases. They also hide possible name collisions since dynamic properties may have the same name as properties defined in the class or object, leading to conflicts or unexpected behavior. Sample Code Wrong class Dream:
    pass

nightmare = Dream()

nightmare.presentation = "I am the Sandman"
# presentation is not defined
# it is a dynamic property

print(nightmare.presentation) 
# Output: "I am the Sandman" Right class Dream:
    def __init__(self):
        self.presentation = None

nightmare = Dream()

nightmare.presentation = "I am the Sandman"

print(nightmare.presentation) 
# Output: "I am the Sandman" Detection Automatic [x] Most languages have compiler options to avoid them. Tags Metaprogramming Conclusion Dynamic properties are supported in many programming languages like PHP,    Python, Ruby,  JavaScript,  C#, Objective-C, Swift, Kotlin, etc. In these languages, dynamic properties can be added to objects at runtime, and accessed using the object's property accessor syntax. Bear in mind that having public attributes favors which is another smell. Anemic Objects Relations Code Smell 109 - Automatic Properties Code Smell 01 - Anemic Models Credits Photo by on Karsten Würth Unsplash It's easy to cry "bug" when the truth is that you've got a complex system and sometimes it takes a while to get all the components to co-exist peacefully. D. Vargas Next week .. fire smells more

How to Find the Stinky Parts of Your Code [Part XLII]

Hey there, fellow JavaScript enthusiasts! Leandro Nuñez, your trusty software engineer, is back with some JavaScript magic. Today, we'll explore the art of JavaScript shorthands - nifty techniques that make your code more concise and elegant. We'll dive into real use case examples in both vanilla JavaScript and the shorthand form. So buckle up, and let's elevate your JavaScript skills to new heights! 1. The Ternary Operator: Conditional Assignment Use Case: Normal JavaScript: let isAdmin;
if (user.role === 'admin') {
  isAdmin = true;
} else {
  isAdmin = false;
} Shorthand: const isAdmin = user.role === 'admin' ? true : false; Shorterhand const isAdmin = user.role === 'admin'; 2. Object Property Shorthand: Creating Objects with Variables Use Case: Normal JavaScript: const name = 'Leandro';
const age = 30;

const person = {
  name: name,
  age: age
}; Shorthand: const name = 'Leandro';
const age = 30;

const person = {
  name,
  age
}; 3. Default Parameter Values: Providing Default Values to Function Parameters Use Case: Normal JavaScript: function greet(name) {
  name = name || 'Guest';
  return `Hello, ${name}!`;
} Shorthand: function greet(name = 'Guest') {
  return `Hello, ${name}!`;
} be careful with this one. Check out this comment by Caution: here 4. Short-Circuit Evaluation: Fallback for Undefined or Null Values Use Case: Normal JavaScript: const username = getUsernameFromAPI();
const displayName = username ? username : 'Anonymous'; Shorthand: const username = getUsernameFromAPI();
const displayName = username || 'Anonymous'; 5. Array Destructuring: Swapping Variables Use Case: Normal JavaScript: let a = 5;
let b = 10;

const temp = a;
a = b;
b = temp; Shorthand: let a = 5;
let b = 10;

[a, b] = [b, a]; 6. Template Literals: Dynamic String Concatenation Use Case: Normal JavaScript: const name = 'Leandro';
const greeting = 'Hello, ' + name + '!'; Shorthand: const name = 'Leandro';
const greeting = `Hello, ${name}!`; 7. Arrow Functions: Concise Function Definitions Use Case: Normal JavaScript: function add(a, b) {
  return a + b;
} Shorthand: const add = (a, b) => a + b; 8. Nullish Coalescing Operator: Providing Default Values for Null or Undefined Variables Use Case: Normal JavaScript: const fetchUserData = () => {
	return 'leandro' // change to null or undefined to see the behavior
};

const data = fetchUserData();
const username = data !== null && data !== undefined ? data : 'Guest'; Shorthand: const fetchUserData = () => {
	return 'leandro' // change to null or undefined to see the behavior
};

const data = fetchUserData();
const username = data ?? 'Guest'; 9. Object Destructuring: Extracting Object Properties into Variables Use Case: Normal JavaScript: const user = {
  name: 'Leandro',
  age: 30,
  country: 'USA'
};

const name = user.name;
const age = user.age;
const country = user.country; Shorthand: const user = {
  name: 'Leandro',
  age: 30,
  country: 'USA'
};

const { name, age, country } = user; 10. Spread Operator: Merging Arrays or Objects Use Case: Normal JavaScript: const arr1 = [1, 2, 3];
const arr2 = [4, 5, 6];
const mergedArray = arr1.concat(arr2); Shorthand: const arr1 = [1, 2, 3];
const arr2 = [4, 5, 6];
const mergedArray = [...arr1, ...arr2]; 11. Logical OR Assignment: Assigning a Default Value to a Variable Use Case: Normal JavaScript: let count;
if (!count) {
  count = 0;
} Shorthand: let count;
count ||= 0; 12. Short-Circuit Evaluation for Function Call: Avoiding Unnecessary Function Execution Use Case: Normal JavaScript: function fetchData() {
  if (shouldFetchData) {
    return fetchDataFromAPI();
  } else {
    return null;
  }
} Shorthand: function fetchData() {
  return shouldFetchData && fetchDataFromAPI();
} There you have it! JavaScript shorthands continue to impress with their elegance and efficiency.
Incorporate these concise examples into your codebase, and watch your JavaScript skills soar to new heights. Happy coding and enjoy unleashing the power of JavaScript shorthands in your projects!

Mastering JavaScript Shorthands

Stories, News & Mentions about TERNARY

Ternary’s Stories on HackerNoon