<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Kaan Ince on Medium]]></title>
        <description><![CDATA[Stories by Kaan Ince on Medium]]></description>
        <link>https://medium.com/@kaaniince?source=rss-502e79383ac0------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*Uw-WpA_8FESx7_EEVxoZGw.jpeg</url>
            <title>Stories by Kaan Ince on Medium</title>
            <link>https://medium.com/@kaaniince?source=rss-502e79383ac0------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Mon, 16 Nov 2026 21:04:18 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@kaaniince/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Setting Up TinyProxy on Azure to Access the Internet via Azure IP]]></title>
            <link>https://medium.com/@kaaniince/setting-up-tinyproxy-on-azure-to-access-the-internet-via-azure-ip-69ebc063ba65?source=rss-502e79383ac0------2</link>
            <guid isPermaLink="false">https://medium.com/p/69ebc063ba65</guid>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[networking]]></category>
            <category><![CDATA[proxy]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[azure]]></category>
            <dc:creator><![CDATA[Kaan Ince]]></dc:creator>
            <pubDate>Sun, 12 Jan 2025 13:12:03 GMT</pubDate>
            <atom:updated>2025-01-12T13:12:03.994Z</atom:updated>
            <content:encoded><![CDATA[<p>In this article, I will guide you through setting up TinyProxy on an Azure cloud virtual machine (VM) to allow internet access through Azure’s public IP. This setup can be useful for various use cases, such as testing services through Azure’s IP or routing traffic for specific purposes.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*s2iwOTLNmsXIzKRp.png" /></figure><h4>Create a Instance</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UY3SsSGuvq2fzEsyyh81Nw.png" /></figure><h4>Manage Account Details</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/924/1*UCwZNB0bENoJjVfjfgC-ZA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/996/1*PV6xFbOTEuR854D3G9w4OA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*84c_AJ9TDGgoFaKCGrrgdQ.png" /><figcaption>We will try to access the internet with this IP address.</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/618/1*sIkbLfr88xytBrVqZ_eqKQ.png" /><figcaption>We write the VM IP address in the HOST section and the username in the username section of the VM.</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/615/1*PKe1gRk4W5NJqhWeic19sA.png" /></figure><h4>Update and Upgrade the System</h4><p>Once the VM is deployed, connect to it using SSH or RDP and update the system:</p><pre>sudo apt update<br>sudo apt upgrade -y</pre><h4>Install TinyProxy</h4><p>Next, install TinyProxy using the following command:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/847/1*N2FJ5nAUQk6HxC5ubYL_XA.png" /></figure><h4>Configure TinyProxy</h4><p>Once TinyProxy is installed, you need to modify its configuration to allow external access.</p><p>Open the TinyProxy configuration file:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/851/1*-OddT45xblcKr-BOG5E9Eg.png" /></figure><p>Find the line that specifies Listen. By default, TinyProxy listens only on 127.0.0.1. Change this to 0.0.0.0 to allow connections from all IP addresses:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/912/1*wOlFKj2dSsMP0EQVBcGj5A.png" /></figure><p>Locate the Allow directive, which restricts access to specific IP ranges. Change it to allow all IPs (this is not recommended for production environments due to security risks):</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/917/1*nByZH2jt7khZHeK8vf42lg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/912/1*3v5QMy-XlkBz8nXQ9RMKVQ.png" /></figure><p>By default, TinyProxy listens on port 8888. You need to ensure that Azure allows traffic on this port.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JjPt1LAPJdxcNDPBYtBM3Q.png" /></figure><p>We type proxy in the browser and enter the instance IP in the manual configuration section.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nCvdSSJtWwEiSRhf0yuO7g.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/747/1*bDC7benpJWoXNhaOokOk-w.png" /></figure><p>“Also use this proxy for HTTPS” is marked.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/734/1*D_Ci971i1Fk7bOoOiX0FFw.png" /></figure><p>At ipnedir.com, we see our IP from which we access the internet.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iHevadWsUFCkUpOufgE3Hg.png" /></figure><p>The logs generated by TinyProxy during its operation are displayed here. These logs show that a request was processed through the proxy and forwarded to the external destination.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rrZGJmK0vFvyo3acP3mk3g.png" /></figure><p>TinyProxy is accepting connections from all IP addresses on port 8888. This means that the proxy is accessible from the external network.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/898/1*kBynDG8zO1Hf6ci039sspA.png" /></figure><h3>Conclusion</h3><p>Setting up TinyProxy on an Azure VM allows you to route internet traffic through Azure’s public IP. While this guide uses a minimal configuration for demonstration purposes, remember to implement proper security measures in a production environment, such as IP whitelisting, authentication, and using secure connections.</p><p>By following this guide, you can quickly set up a functional proxy service and start routing traffic through your Azure VM. Happy testing!</p><p>References:</p><p><a href="https://learn.microsoft.com/en-us/azure/?product=popular">https://learn.microsoft.com/en-us/azure/?product=popular</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=69ebc063ba65" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Leveraging Entity Framework Core with Database-First Approach for Robust Data Access]]></title>
            <link>https://medium.com/@kaaniince/leveraging-entity-framework-core-with-database-first-approach-for-robust-data-access-56b365e39602?source=rss-502e79383ac0------2</link>
            <guid isPermaLink="false">https://medium.com/p/56b365e39602</guid>
            <category><![CDATA[database-first]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[net-core]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[entity-framework-core]]></category>
            <dc:creator><![CDATA[Kaan Ince]]></dc:creator>
            <pubDate>Mon, 14 Oct 2024 11:20:02 GMT</pubDate>
            <atom:updated>2024-10-14T11:20:02.473Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Entity Framework Core (EF Core) is a powerful Object-Relational Mapping (ORM) tool that streamlines data access in .NET applications. This article explores the Database-First approach with EF Core, highlighting its benefits, challenges, and best practices.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/0*tKK9pjo1Qw_xz9Eb.png" /></figure><p><strong>Understanding ORM and LINQ</strong></p><p>ORM is a technique that maps class properties to database columns, allowing developers to interact with the database in a more intuitive way. EF Core facilitates this mapping, enabling type-safe database operations. LINQ (Language Integrated Query) complements ORM by allowing queries against various data types, such as object collections, XML, and entities.</p><p><strong>LINQ to Objects: </strong>This allows querying in-memory collections.</p><p><strong>Type Safety</strong>: LINQ queries are strongly typed, reducing runtime errors.</p><h4>Advantages of Using EF Core</h4><ul><li><strong>Type Safety</strong>: Work with the database in a type-safe manner.</li><li><strong>Abstraction</strong>: The complexities of database operations are abstracted away.</li><li><strong>Security</strong>: EF Core provides natural protection against SQL injection vulnerabilities.</li></ul><h4>Challenges to Consider</h4><ul><li><strong>Limited Query Access</strong>: While EF Core simplifies data access, not all SQL queries can be executed directly.</li></ul><h4>Compatibility with Relational Databases</h4><p>EF Core is compatible with various relational databases, including PostgreSQL, SQL Server, MySQL, and Oracle. It also supports SQLite and InMemory databases, though the latter is primarily used for testing due to its limited scalability. Notably, EF Core does not support MongoDB.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ZU3cG-TesQHoMqFW.jpg" /></figure><h4>Database-First vs. Code-First Approaches</h4><ul><li><strong>Database-First</strong>: This approach starts with the database design, where tables are created first, followed by generating object classes in the application. Each class corresponds to a database table (entities).</li><li><strong>Code-First</strong>: This method involves writing the code first, where the class definitions dictate the database schema. Migrations are used to keep the database synchronized with code changes.</li></ul><h4>Best Practices for Database-First Approach</h4><ol><li><strong>Primary Key Requirement</strong>: Ensure every table has a primary key. If it doesn’t, specify it explicitly.</li><li><strong>DbContext and DbSet</strong>: Use DbContext to represent the database connection, while DbSet represents the tables.</li><li><strong>Configuring DbContext</strong>: Set up your DbContext with the necessary configurations in appsettings.json.</li><li><strong>Using Dependency Injection</strong>: Employ the using statement to manage resource allocation effectively.</li></ol><h4>Setting Up Database-First in EF Core</h4><ol><li><strong>Creating the Database</strong>: Start by creating the database in SQL Server.</li><li><strong>Defining the Data Access Layer (DAL)</strong>: Create a folder named DAL to contain your DbContext class.</li><li><strong>Creating Entity Classes</strong>: Define classes that correspond to your database tables, including properties for each column. In this section, we will add the AppDbContext, DbContextInitializer, and the database table classes that correspond to your database schema. This setup is crucial for managing your data access layer effectively.</li><li><strong>Connecting to the Database</strong>: Configure your database connection string in appsettings.json, ensuring it points to the correct database.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Vhq3waqU72TPPhUGjUHe2w.png" /><figcaption>The connection string can be found in the SQL Server Object Explorer section of the View tab. This connection string will later be added to the <strong>appsettings.json</strong> file.</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DFoybl4st3opNctAEgBRLw.png" /></figure><p><strong>Using Scaffold for Efficient Model Creation</strong></p><p><em>To avoid manually creating each table’s model, use the </em><em>Scaffold-DbContext </em>This command generates model classes for all tables in the specified database. With this command, code lines generated from DbContext will be created under the folder. Subsequently, the classes corresponding to the tables within the database will also be generated under this folder.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/985/1*jisnH0lII2R337kfVU1g5A.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/546/1*M2Wx50Bo-hnyB_1Ce-vsuA.png" /></figure><h4>Transitioning to Code-First</h4><p>After scaffolding, it’s advisable to proceed with a Code-First approach. This allows you to refine and extend your models without the risk of overwriting existing configurations.</p><p>References:</p><p><a href="https://github.com/kaaniince/EFCore">GitHub - kaaniince/EFCore</a></p><p><a href="https://www.codeproject.com/Articles/1209903/Getting-Started-with-Entity-Framework-Core-Databas">https://www.codeproject.com/Articles/1209903/Getting-Started-with-Entity-Framework-Core-Databas</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=56b365e39602" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Enhancing Project Architecture with AWS RDS and EC2]]></title>
            <link>https://medium.com/@kaaniince/enhancing-project-architecture-with-aws-rds-and-ec2-ecc446fcb278?source=rss-502e79383ac0------2</link>
            <guid isPermaLink="false">https://medium.com/p/ecc446fcb278</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[wordpress]]></category>
            <category><![CDATA[aws]]></category>
            <dc:creator><![CDATA[Kaan Ince]]></dc:creator>
            <pubDate>Tue, 03 Sep 2024 10:24:10 GMT</pubDate>
            <atom:updated>2024-09-03T10:24:10.079Z</atom:updated>
            <content:encoded><![CDATA[<p><em>We will set up our WordPress project using AWS RDS and EC2 services, including configuring load balancing to handle high traffic. This guide will walk you through each step of the process. By the end, you’ll have a fully functional WordPress site running efficiently with AWS services. Let’s dive in!</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/780/0*_J7ExgDEj5xGKul0.jpg" /></figure><h4>Creating RDS</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eh6csolG2zecIcKjn584uA.png" /></figure><p>In the AWS RDS section, we click on “Create database.” Our RDS system will be Standard, and we’ll select MySQL as the engine type. You can choose the template according to your preference. For this project, I selected the Free Tier option.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fKDwrYunTvwSGND_sC4B4g.png" /></figure><p>The RDS Credentials Settings have been configured. Don’t forget to save the master username and password somewhere secure.</p><p>You can leave the Security Group section as default.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Kcssjpm68pgiJ4eN7ZKnyg.png" /></figure><p>In the Additional Configuration section, you can add tables to the database you’re creating. Additionally, we will do this in Workbench as well. After making the necessary adjustments, click “Create Database.” This will create an instance, which may take 3–4 minutes to complete.</p><p>In the Connectivity &amp; Security section of the created instance, the Endpoint &amp; Port section displays the IP address of the RDS database.</p><h4>Creating EC2</h4><p>After creating the RDS instance, we will create an EC2 instance running Ubuntu. In the Key Pair section, if you have previously created a key pair for Ubuntu, you can select it. If not, you can create a new key pair. This process will download a .pem file to your local machine.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*b3sxOANqy1VwGp8bp7dtfg.png" /></figure><p>We want our server to be in the same subnet as the RDS instance. Therefore, we select the default EC2 security group.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*M6HtAwon1EaVaJo3TKSwxA.png" /></figure><p>We create the instance by clicking on &quot;Launch Instance.&quot;</p><p>You can connect to the EC2 instance by selecting the “Connect” option. If that doesn’t work, you can also access it using an SSH client. In the SSH client:</p><ul><li>Enter the instance’s IP address in the “Host” field.</li><li>Use “ubuntu” as the username.</li><li>For the “Client Key Manager,” select the .pem file you downloaded when creating the EC2 instance.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/712/1*qeqnaPL5bv-N6-ZqJpYhgQ.png" /></figure><blockquote>If you encounter connection errors, make sure to add HTTP, SSH, and RDP rules to the inbound rules section of the EC2 instance’s security group, and set the source to “Anywhere.”</blockquote><h4>Installing Nginx</h4><p>We are installing the Nginx server for our project. Use the command sudo apt install nginx -y (nginx also supports load balancing )</p><p>You can check the status of the Nginx installation with the command: sudo systemctl status nginx.</p><p>If Nginx is running, you should see that it is listed as “active” in the output.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1007/1*bghTGF8d12fHuVQJnwkQew.png" /></figure><p>Nginx can serve both static (HTML, CSS, etc.) and dynamic (Node.js, PHP, WordPress, etc.) web services. Since our WordPress project is PHP-based, we need to install PHP. Use the command sudo apt install php-fpm php-mysql php-xml php-curl php-mbstring -y.</p><p>We are installing WordPress on the Nginx server. Use the command sudo wget https://wordpress.org/latest.tar.gz to download the WordPress package.</p><p>We are extracting the downloaded WordPress package. Use the command sudo tar -xvzf latest.tar.gz to unzip the file.</p><p>We are moving all the files from the WordPress directory to the web server’s root directory. Use the command sudo mv wordpress/* /var/www/html/ to transfer the files.</p><p>To complete the project setup, use the following commands:</p><ul><li>sudo chown -R www-data:www-data /var/www/html/</li><li>sudo chmod -R 755 /var/www/html/</li><li>cd /var/www/html/</li></ul><p>We create a copy of the wp-config-sample.php file as wp-config.php using the command sudo cp wp-config-sample.php wp-config.php.</p><p>We access the content of the file using the command sudo nano wp-config.php.</p><p>We fill in the necessary sections of the wp-config.php file. Enter the values provided by AWS for the variables. For DB_HOST, use the endpoint and port information found in the Connectivity &amp; Security section.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/917/1*t6diRgmsLvAGzXzjwj0PYw.png" /></figure><p>We access the directory by navigating to it with the command cd /etc/nginx from our current location.</p><p>The file is opened with cat nginx.conf. Then, execute the following commands sequentially, and the default file is deleted.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/997/1*l2ogSVZC5uVG7rFE1wrMng.png" /></figure><p>Use the command sudo unlink /etc/nginx/sites-available to remove the symbolic link to the file.</p><p>Next, we will create a configuration file using the command sudo nano wordpress. In the opened wordpress file, you will enter the server-related information as shown below. Additionally, make sure to specify the server_name with the EC2 IP address you created.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/992/1*RkFgCKSKiB40xmNg7_-Dlw.png" /></figure><p>We need to indicate that the file we added is a configuration file for Nginx. Use the command sudo ln -sf /etc/nginx/sites-available/wordpress /etc/nginx/sites-enabled to create a symbolic link.</p><p>Use the command sudo systemctl restart nginx to restart Nginx. If there is an error during the restart, it would indicate that there is an issue with the configuration or the service.</p><p>After configuring our WordPress file and entering the RDS information, we linked the available section. Then, we restarted the folder. When we checked the EC2 instance, we saw that port 80 was open to &quot;Anywhere&quot; in the Security &gt; Inbound section.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*51uTV030GGhGRbH2WPjHow.png" /></figure><p>We connect the created <strong>website-db</strong> RDS instance to the <strong>EC2 instance</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bfBs5dx1bCtkoieOZ65bgw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nz_FY6pWzCxVWo3HOUsS2Q.png" /></figure><h4>Opening Wordpress</h4><p>When you enter the EC2 IP address into your browser, the WordPress installation page will appear.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*y1w5FlXDaWPII47IEc-HEg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6Qa1hc1deM3dFmCgyYz8yw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-2ftlg68LvU_jmDOOyfQ6g.png" /></figure><p>Our project is now up and running. Additionally, you can use your domain service to make your project live.</p><h4><strong>Creating Load Balancer</strong></h4><p>If your web project experiences high traffic, server issues may arise. To address this, AWS’s Load Balancing service will be used.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fDMMDBiLDfyZNiS4o5mWnw.png" /></figure><p>We select “internal” for the schema and select all the fields, including the zone.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JYrInMgPtLwdjoBLytELWA.png" /></figure><p>In the Listeners and Routing section, we will choose which instance the incoming requests will be directed to. However, first, click on “Create Target Group.”</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*s22Et-Bss67MAExemsu4ZQ.png" /></figure><p>We create and select a target group with the EC2 instance we are using. Our load balancer is now created.</p><p>In the Target Groups section, after selecting the second instance from the “Register Targets” section, you can choose it by clicking the “Include as pending below” button.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-91CIOfSS6auSNFZmp_u8g.png" /></figure><p>In the Target section, both servers have been added and are now active on our load balancer.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IdgczQF37PkxqMDeyENrIQ.png" /></figure><p>After adding the Load Balancer’s DNS Name to the DNS server, we will be able to experience the load balancing process live.</p><p>References:</p><p><a href="https://aws.amazon.com/tr/developer/learning/">Developer Learning, Trainings, Courses, and Resources - AWS</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ecc446fcb278" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Model Training]]></title>
            <link>https://medium.com/@kaaniince/model-training-442b2f4b296?source=rss-502e79383ac0------2</link>
            <guid isPermaLink="false">https://medium.com/p/442b2f4b296</guid>
            <category><![CDATA[design-patterns]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Kaan Ince]]></dc:creator>
            <pubDate>Sun, 09 Apr 2023 14:49:40 GMT</pubDate>
            <atom:updated>2023-04-09T14:49:40.093Z</atom:updated>
            <content:encoded><![CDATA[<p>Design Patterns</p><h3><strong>Useful Overfitting</strong></h3><p>In physics or mathematics, there are often complex problems that require a significant amount of computational power and expertise to solve. However, the concept of “useful overfitting” has been shown to be effective in helping to address such problems.</p><p>Overfitting refers to a situation where a model is trained too well on a specific dataset, to the point that it becomes too specialized and cannot generalize well to new data. However, in some cases, overfitting can be useful. Specifically, if a model is overfit to a dataset that is similar to the problem at hand, it can be used to make predictions on that specific problem with greater accuracy.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*wsYkbdOFmgAMaN9U.png" /></figure><blockquote>One approach to addressing overfitting is to train a model with a larger dataset. However, this may not always be possible due to limitations in available data. Another approach is to use distillation of knowledge, which involves training a smaller model to mimic the behavior of a larger, more complex model. This technique can be useful in cases where the larger model is too complex to be used in a production setting, or when working with limited data.</blockquote><blockquote><strong>Distillation of knowledge</strong> can also be used to transfer knowledge from a pre-trained model to a new model. This approach can be particularly useful when working with limited data, as the pre-trained model can provide a good starting point for the new model. However, it’s important to verify whether the larger model has correctly learned the data or not, especially if <strong>overfitting </strong>occurred during training with a large <strong>batch </strong>size. If the model overfits even with a small dataset, the parameters may not be well-suited to the task at hand.</blockquote><h3>Checkpoints</h3><p>In the process known as Checkpoints, we periodically save the complete state of the model in order to have partially trained models available. These partially trained models can serve as the final model (in the case of early stopping) or as starting points for continued training (in the cases of machine failure and fine-tuning).</p><p>Complex models often have a large number of tunable parameters. As model sizes increase, the time it takes to fit one batch of examples also increases. Furthermore, as the data size increases (assuming fixed batch sizes), the number of batches also increases. This double whammy of factors results in a longer training time due to the computational complexity of the process.</p><p>Increasing the training time also increases the likelihood of encountering an error during training. If a problem does occur, we would prefer to be able to resume training from an intermediate point, rather than starting from the very beginning again.</p><blockquote>While a particular model may fail to perform as intended, the underlying neural network architecture is designed to handle a wide range of problems.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*LR65TqEcJsZWVeJ7.jpg" /></figure><h3>Transfer Learning</h3><p>Transfer learning is a technique in machine learning where we use a pre-trained model and incorporate it into a new model to solve a similar problem, but on a smaller dataset. This involves taking part of the previously trained model, freezing the weights, and integrating these nontrainable layers into the new model.</p><p>Custom machine learning models trained on unstructured data require extremely large datasets, which are often not readily available. This is especially true for organizations that have specialized prediction problems and don’t have access to a lot of data. Transfer learning allows these organizations to leverage pre-trained models and transfer knowledge from the existing models to new ones, which can be fine-tuned to solve the specific prediction problem.</p><p>By using transfer learning, organizations can significantly reduce the amount of data required to train a custom model, while still achieving high levels of accuracy. This is because pre-trained models have already learned a lot of useful features and patterns from large datasets, which can then be transferred to a new model to learn from smaller datasets. This approach not only saves time and resources, but it also enables organizations to rapidly develop and deploy custom models to solve their specific prediction problems.</p><p>There are two main stages in transfer learning: <strong>feature extraction</strong> and <strong>fine-tuning</strong>.</p><p>During feature extraction, the pre-trained model’s weights are frozen, and only the last layer is trained on the new data. This allows us to leverage the pre-trained model’s knowledge of general features and patterns in the data, while still allowing the model to learn task-specific features. The goal is to extract useful features from the pre-trained model and then use them as inputs for a new model, which can then be trained on the specific task at hand.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*KUhPuTB6OZyWk5xY.png" /></figure><p>The fine-tuning stage involves unfreezing some of the layers of the pre-trained model and continuing the training process on the new data. This approach allows us to further adapt the pre-trained model to the specific task at hand, by fine-tuning the existing features to be more relevant to the new data. Fine-tuning can also be used to improve the model’s performance on the new data, by adjusting the weights of the pre-trained model to better fit the new data.</p><h3>Distribution Strategy</h3><p>Distribution Strategy, which allows for the training loop to be carried out at scale over multiple workers. This technique often involves caching, hardware acceleration, and parallelization to speed up the training process and reduce the time it takes to iterate on new ideas.</p><p>While it may not always be feasible to break down complex problems into smaller components or work with only a subset of the data, Distribution Strategy offers a way to tackle these challenges head-on and make progress in the field of deep learning. By leveraging the full scale of the data and the power of distributed computing, researchers can train large neural networks more quickly and efficiently than ever before.</p><p>Using Distribution Strategy, researchers can implement data parallelism to distribute the training of large neural networks across multiple workers. This allows for the computation of gradients and the sharing of information to make updates to the model parameters. By ensuring that all workers are consistent, each gradient step works to train the model effectively.</p><blockquote>Data parallelism can be carried out either synchronously or asynchronously. In synchronous training, the workers train on different slices of input data in parallel, and the gradient values are aggregated at the end of each training step. This approach can be helpful in ensuring that all workers are in sync and that the model is trained efficiently.</blockquote><blockquote>On the other hand, asynchronous training involves workers training on different slices of the input data independently. The model weights and parameters are updated asynchronously, typically through a parameter server architecture. This approach can be more efficient as it does not require waiting for all workers to finish their computations before moving on to the next step. However, it can also be more challenging to maintain consistency across workers and ensure the model is trained effectivel</blockquote><h3>Hyperparameter Tuning</h3><p>Hyperparameters are parameters in a machine learning model that are not learned from the data, but rather set by the user before training. They control aspects of the learning process, such as the learning rate, the number of hidden layers in a neural network, or the regularization strength. In Hyperparameter Tuning, the process of finding the optimal set of hyperparameters is itself inserted into an optimization method, which can involve techniques such as grid search, random search, or Bayesian optimization. By tuning hyperparameters, researchers can improve the performance of their models and achieve better results on new, unseen data.</p><blockquote>Grid search involves trying out all possible combinations of hyperparameters within a specified range, essentially performing a brute-force search. However, this approach can become computationally expensive when the search space is large, leading to long training times and high computational costs.</blockquote><p><strong>Bayesian Optimization vs. Grid Search</strong></p><p>Bayesian optimization often requires less data and fewer model trials than grid search, and therefore can produce results more quickly. However, Bayesian optimization can also be computationally expensive, as it requires more computational power to evaluate the performance of each model. While grid search exhaustively tries all possible combinations, allowing for a comprehensive analysis of results, this approach can be costly for large search spaces.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=442b2f4b296" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Problem Representation]]></title>
            <link>https://medium.com/@kaaniince/problem-representation-5bcb248ef2b8?source=rss-502e79383ac0------2</link>
            <guid isPermaLink="false">https://medium.com/p/5bcb248ef2b8</guid>
            <category><![CDATA[mlops]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[data-science]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Kaan Ince]]></dc:creator>
            <pubDate>Sat, 08 Apr 2023 17:52:53 GMT</pubDate>
            <atom:updated>2023-04-08T17:52:53.901Z</atom:updated>
            <content:encoded><![CDATA[<p>Design Patterns</p><h3><strong>Reframing</strong></h3><p>When we are dealing with a regression problem, we try to predict a continuous output variable based on one or more input variables. However, sometimes we may want to approach the problem as a classification task, where we try to predict a categorical variable instead.</p><p>For example, let’s say we want to predict the amount of rainfall for a given day. This is a typical regression problem, where we use historical data to predict the amount of rainfall in millimeters. However, if we want to convert this problem to a classification task, we can categorize the amount of rainfall into different classes, such as “heavy rain”, “light rain”, “no rain”, and “moderate rain”. We can then assign the corresponding rainfall values to each category.</p><p>In some scenarios, we may want to convert a rating system, where we have a range of possible scores, into a binary classification problem, where we only have two classes. For instance, let’s say we have a rating system that ranges from 1 to 5, and we want to classify each rating as either “liked” or “disliked”. In this case, we can set a threshold score that separates the two classes, such as 3. If a rating is equal to or greater than 3, we can classify it as “liked”, and if it is less than 3, we can classify it as “disliked”.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/720/0*M5UprKH_rLpNQDh-.jpg" /></figure><blockquote>When working on a predictive modeling problem, it is common to approach it either as a regression or classification task depending on the nature of the problem. However, in some cases, it may be beneficial to use both techniques together to get a more accurate prediction.</blockquote><blockquote>Let’s consider an example where we want to predict the price of a house based on various features such as location, size, and number of bedrooms. This is a typical regression problem, where we aim to predict a continuous variable. However, we may also want to classify the houses into different categories such as “luxury”, “medium”, and “affordable” based on their price range. This is a classification problem where we aim to predict a categorical variable.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*HD2ygjV2vRhQufh-.jpg" /></figure><h3>Multilabel</h3><p>When we are dealing with a classification problem, we try to predict a categorical variable based on one or more input variables.</p><blockquote>However, there are different types of classification problems, such as multiclass and multilabel classification.</blockquote><blockquote>For example, consider a scenario where we want to classify an image of an animal as either a cat, a dog, or a bird. This is an example of a multiclass classification problem, where each image can belong to only one class.</blockquote><blockquote>On the other hand, in a multilabel classification problem, each input can have multiple labels assigned to it. For instance, imagine a situation where a person is taking care of a monkey for a few weeks. During this period, the monkey may exhibit various behaviors such as eating bananas, climbing trees, and playing with toys. In this case, we can assign multiple labels to the monkey, such as “eats bananas”, “climbs trees”, and “plays with toys”. Therefore, the monkey data can be considered as an example of a multilabel classification problem.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/605/0*NP-rr0-FdJ4miZeN.png" /></figure><p><strong>Sigmoid activation and softmax activation functions</strong> normalize output values between 0 and 1. However, softmax ensures that the sum of all probabilities equals 1, whereas sigmoid does not. This makes softmax more suitable for solving multi-class problems. By using softmax, we can obtain probabilities for each class, and the class with the highest probability can be selected as the predicted class.</p><h3>Ensembles</h3><p>The Ensembles design pattern in machine learning involves combining multiple machine learning models and using their results to make predictions. No machine learning model is perfect, and in order to better understand where and how our model is inaccurate, we can break down the error into three parts: irreducible error, error due to bias, and error due to variance.</p><p>Irreducible error is the inherent error in the model resulting from noise in the dataset, the framing of the problem, or bad training examples, such as measurement errors or confounding factors. Unfortunately, as the name implies, there isn’t much we can do to reduce irreducible error.</p><p>The other two errors, bias and variance, are referred to as reducible errors, and these are where we can have an impact on our model’s performance. In short, bias is when the model is unable to learn enough about the relationship between its features and labels, while variance captures the model’s inability to generalize to new, unseen examples.</p><h4>Solution</h4><blockquote><strong>Bagging</strong></blockquote><blockquote>Bagging (short for bootstrap aggregating) is a type of parallel ensembling method and is used toaddress high variance error in machine learning models.</blockquote><blockquote><strong>Boosting</strong></blockquote><blockquote>Boosting ultimately constructs an ensemble model with more capacity than the individualmember models. For this reason, boosting provides a more effective means of reducingbias than variance.Boosting iteratively improves upon a sequence of weak learners taking a weightedaverage to ultimately yield a strong learner.Some of well-known boosting algorithms are AdaBoost, Gradient Boosting Machines,XGBoost.</blockquote><blockquote><strong>Stacking</strong></blockquote><blockquote>Stacking is an ensemble method that combines the outputs of a collection of modelsto make a prediction.The initial models, which are typically of different model types, are trained to completionon the full training dataset. Then, a secondary meta-model is trained using the initialmodel outputs as features. This second meta-model learns how to best combine theoutcomes of the initial models to decrease the training error and can be any type ofmachine learning model</blockquote><h3>Cascade</h3><p>Cascading models are a type of machine learning approach where multiple models are used in a sequence, with the output of one model being used as the input to the next model in the sequence. This approach is also known as a pipeline or a chain of models.</p><p>Cascading models are often used in complex tasks where a single model cannot accurately capture all the necessary information or where the data is too large to be processed by a single model. By breaking down the task into smaller, more manageable pieces, cascading models can improve the overall accuracy and efficiency of the prediction process.</p><blockquote>For example, in natural language processing, a cascading model might use a language identification model to determine the language of the input text, followed by a tokenizer to break the text into individual words, then a part-of-speech tagger to identify the grammatical structure of each word, and finally a named entity recognizer to identify and extract named entities such as people, organizations, and locations.</blockquote><p>The success rate of the first model is crucial in a cascading model approach. If the success rate of the first model is low, this will carry forward through the chain of models. Therefore, it is important to ensure that the first model in the cascade is accurate and reliable. This can be achieved through careful selection of the model architecture, appropriate training data, and thorough evaluation of the model’s performance. Additionally, it is important to regularly monitor the performance of the entire cascading model to ensure that each subsequent model is benefiting from the best possible input. By maintaining a high level of accuracy in the first model, the overall effectiveness of the cascading model can be greatly improved.</p><h3>Neutral Class</h3><p>In many classification situations, creating a neutral class can be helpful in improving the accuracy and interpretability of the model. The neutral class is typically used to represent cases where the data is ambiguous or uncertain, and can be particularly useful in scenarios where the decision boundary between positive and negative outcomes is unclear.</p><p>The introduction of a neutral class allows the model to more accurately reflect the underlying distribution of the data, and provides a more nuanced prediction that is not limited to binary outcomes. For example, in a sentiment analysis task, a three-class classifier can be used to identify not only positive and negative sentiment, but also cases where the sentiment is neutral or undecided.</p><p>The use of a neutral class can also help to reduce bias in the model by preventing it from making overly confident predictions in cases where the data is ambiguous. This can be particularly important in applications such as medical diagnosis, where false positives or false negatives can have serious consequences.</p><p>Overall, the use of a neutral class in classification models can improve the accuracy and interpretability of the model, and can be particularly useful in scenarios where uncertainty or ambiguity is present in the data. However, the selection of an appropriate neutral class can be challenging, and careful consideration should be given to the design of the model and the specific needs of the application.</p><h3>Rebalancing</h3><p>Rebalancing refers to the process of adjusting the class distribution of a dataset to improve the performance of a machine learning model. In many real-world applications, datasets are often imbalanced, meaning that one or more classes have significantly fewer examples than others. This can lead to biased models that perform poorly on minority classes.</p><p>Rebalancing can be done in several ways, such as oversampling, undersampling, or a combination of both. Oversampling involves creating additional samples for the minority class, while undersampling involves removing samples from the majority class. Both approaches aim to balance the class distribution of the dataset, with the goal of improving the model’s ability to accurately predict all classes.</p><blockquote>For example, in a credit card fraud detection task, the fraudulent transactions are likely to be rare compared to legitimate transactions. If the dataset is imbalanced, a machine learning model trained on it may have a high accuracy for the majority class (legitimate transactions), but perform poorly on the minority class (fraudulent transactions). Rebalancing techniques can be used to adjust the class distribution of the dataset, making it possible to build a more accurate and balanced model.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/668/0*SOityEy6ptk02Y04" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5bcb248ef2b8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Fire Within DevOps]]></title>
            <link>https://medium.com/@kaaniince/the-fire-within-devops-c2d74da053bf?source=rss-502e79383ac0------2</link>
            <guid isPermaLink="false">https://medium.com/p/c2d74da053bf</guid>
            <category><![CDATA[development]]></category>
            <category><![CDATA[engineering]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Kaan Ince]]></dc:creator>
            <pubDate>Fri, 07 Apr 2023 08:57:42 GMT</pubDate>
            <atom:updated>2023-04-07T08:57:42.606Z</atom:updated>
            <content:encoded><![CDATA[<p>Exploring the Magma of Software Development</p><h3><strong>The Power of TDDs</strong></h3><p>A technical design document (TDD) is a document that describes how a piece of software will be implemented and how it will work. It typically includes detailed information about the system’s architecture, modules, interfaces, and data structures, as well as information about any external dependencies or required resources.</p><p>A technical design document is used to guide the development of a software system, and can be used to communicate the technical aspects of the system to stakeholders and developers.</p><h4>Your First TDD</h4><p>There is no standardized way to writing documentation. The best advice Iʼve ever been given was focus only on the specific issue or problem. Ask yourself what the problem IS and tell the story around that. Set proper boundaries if you need to and include an “out-of-scope” section when you discover items outside of the current issues problem resolution path.</p><p>Apply existing common practices to problem solving that the organization has agreed upon. In this case, we can use the “Three W’s of Strategy” to help solve our problem.</p><p><a href="https://medium.com/@kaaniince/b61175a9fc7b"><em>You can see what the Three W’s of Strategy are by clicking here</em></a></p><ul><li>What problem are we trying to solve? (you should always have this)</li><li>What is the current process? (optional, though normally helpful)</li><li>What are the requirements? (optional, can help with scope)</li><li>How do we solve this problem? (you should always have this)</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*K4fvc9TejPfj0Ke_.jpeg" /></figure><h3>Let’s Do a Practice Exercise</h3><h4>Problem</h4><p>We currently have no way to monitor stream output logs from services and other things running in our Kubernetes cluster.</p><p>We have <strong>no logs</strong>, <strong>where do we start on this topic</strong>? <strong>How do we do logging currently?</strong></p><p><strong>Requirements</strong></p><ul><li>We only care about <strong>stdio</strong> -no use for fields advanced indexing, etc.</li><li>We donʼt want to have to manage infrastructure.</li><li>We only want to solve simple logging for all of our services in Kubernetes to unblock when we have errors and need to find them, history, etc.</li><li>We donʼt want to deal with metrics right now</li></ul><p><strong>Self Hosted</strong></p><ul><li>Loki (with Grafana) : Free and includes most features. The query language is very adoptable and simple</li><li>Elastic with Kibana (ELK) : Free but limited with features (licensed). Provides a lot of extensibility with searching logs</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IFpJkyYOPEBu38w2csVdDg.jpeg" /></figure><p><strong>Cloud Hosted</strong></p><ul><li>Grafana Cloud [Loki w/ Grafana] (base free — 50GB)</li><li>Solarwinds Papertrail (base $7–1GB)</li><li>Elastic Cloud (base $95)</li><li>Solarwinds Loggly (base $79)</li><li>AWS OpenSearch (base $80–50GB + cluster instances)</li><li>New Relic (base free — 100GB)</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/780/0*2fuNN5ac7Hj_jKNa.jpg" /></figure><p>Self-hosted DevOps generally provides more control and flexibility, but requires higher installation, maintenance, and backup costs. In addition, self-hosted DevOps is dependent on the characteristics of your local network or server, which can make it more difficult to expand or scale.</p><p>On the other hand, <strong>cloud-hosted</strong> DevOps services provide more advantages in terms of scalability and flexibility. <strong>Cloud-hosted</strong> DevOps can be deployed quickly and is often easily scalable, making it more suitable for achieving faster results. Additionally, many cloud-hosted DevOps services provide users with less maintenance and backup burdens.</p><blockquote>First, a tool is selected from the self-hosted section, and then a cloud-hosted option can be considered based on the advantages, depending on the problem at hand.</blockquote><blockquote>As a DevOps engineer, you should be prepared to provide the best solution to the company.</blockquote><p><strong>Proposed Solution</strong></p><p>Looking at the list above there is only one solution that really stands out to solving our problem the quickest with best accuracy:</p><ul><li>Grafana Cloud</li></ul><blockquote>Based on initial evaluations, Loki could be selected as a self-hosted option because we appreciate its user-friendly interface and functionality. Later on, from the cloud-hosted section, Grafana Cloud could be considered as a viable option. However, it is important to remember that we are open to evaluating other options in the future. As our needs and requirements change, we will continue to explore and assess different solutions to ensure we are using the best tool for the job. (Assuming we are working with a new company, cost should be kept at a minimum, and therefore Grafana Cloud could be selected.)</blockquote><p><a href="https://foggy-tabletop-55d.notion.site/Fragmented-Documentation-with-Perpetuating-Tribal-Knowledge-de8395e9cd5d459482d2ef90156824f4">A sample Technical Design Document has been created for this article. You can access the Notion page by clicking on this text.</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c2d74da053bf" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Unleashing the Power of DevOps]]></title>
            <link>https://medium.com/@kaaniince/unleashing-the-power-of-devops-b61175a9fc7b?source=rss-502e79383ac0------2</link>
            <guid isPermaLink="false">https://medium.com/p/b61175a9fc7b</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[engineering]]></category>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[planning]]></category>
            <dc:creator><![CDATA[Kaan Ince]]></dc:creator>
            <pubDate>Thu, 06 Apr 2023 21:04:35 GMT</pubDate>
            <atom:updated>2023-04-06T21:04:35.307Z</atom:updated>
            <content:encoded><![CDATA[<p>An Explosive Journey into the Core</p><h3><strong>What DevOps IS</strong></h3><p>The goal of DevOps is to improve the speed and reliability of software releases by automating parts of the software development and deployment process, and by fostering a culture of collaboration and experimentation among teams.</p><p>DevOps is a philosophy or mindset that emphasizes collaboration, communication, and integration between software developers and IT operations teams.</p><h3>What DevOps IS NOT</h3><p>DevOps is not a specific tool or technology. It is not a job title or a job description, and it is not a standalone practice that can be implemented in isolation.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/605/0*Qpqxf50LXZLb0DBJ.png" /></figure><p>The three W’s of strategy are:</p><p><strong>Why </strong>— reasons and motivations behind the strategy.</p><p><strong>What </strong>— goals and objectives that the strategy is intended to achieve.</p><p><strong>Who </strong>— people who are benefiting from this. Together, these three W’s help to provide a clear understanding of the strategy and what it aims to accomplish.</p><blockquote>DevOps standards are guidelines or best practices that organizations can follow to implement standards successfully. These standards typically cover areas such as communication, collaboration, and automation, and can help organizations to improve their software development process and deliver better products to their customers.</blockquote><h3>Standards vs. Rules</h3><ul><li>Automating the software development and deployment process, using tools such as continuous integration and delivery (CI/CD). (Automation Standards)</li><li>Using agile software development methodologies, such as Scrum or Kanban, to increase collaboration and flexibility. (Planning Standards)</li><li>Implementing strict version control and configuration management processes to ensure that software is properly tested and deployed. (Quality Standards)</li><li>Encouraging open communication and collaboration among all members of the development team, including developers, IT operations professionals, and business stakeholders. (Communication Standards)</li><li>Using metrics and data to track and improve the performance of the software development process. (Improving Standards)</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*YaXimC6MebUo0Rqa.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b61175a9fc7b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Gotik Dönemi]]></title>
            <link>https://medium.com/@kaaniince/gotik-d%C3%B6nemi-34ba96f749f3?source=rss-502e79383ac0------2</link>
            <guid isPermaLink="false">https://medium.com/p/34ba96f749f3</guid>
            <category><![CDATA[avrupa]]></category>
            <category><![CDATA[sanat-tarihi]]></category>
            <category><![CDATA[notre-dame]]></category>
            <category><![CDATA[mimari]]></category>
            <category><![CDATA[sanat]]></category>
            <dc:creator><![CDATA[Kaan Ince]]></dc:creator>
            <pubDate>Wed, 15 Mar 2023 09:13:40 GMT</pubDate>
            <atom:updated>2023-03-15T09:13:40.957Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>Gotik dönemi</strong>, özellikle Fransa’da doğmuş ve Orta Çağ Avrupa’sında (12. yüzyıl sonları — 15. yüzyıl başları) bir sanat ve mimarlık akımıdır. Bu dönem, Roma Katolik Kilisesi’nin hâkimiyeti altındaki dini sanatın yoğunlaştığı bir dönemdir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*YQOGkH4vQxXyuxnM.jpeg" /></figure><p>Gotik sanatın en belirgin özellikleri arasında, doğanın detaylı bir şekilde tasvir edilmesi, duvarlarda, camlarda ve vitraylarda yoğun kullanımı olan yüksek ve uzun sivri kemerler, yivli sütunlar, kemerli tonozlar ve çıplak yüzeylerde kabartma figürler yer almaktadır. Sanatın başlıca amacı, Kilise’nin gücünü ve zenginliğini yansıtmaktır.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*3m5JSBGYmCx9MCsS.jpg" /></figure><p>Gotik sanat, Romanesk sanattan farklı olarak daha ince, daha yüksek ve daha zarif hatlara sahiptir. Bu dönemde sanat, kiliselerin iç ve dış mekânlarını süslemek amacıyla kullanılmıştır. Gotik sanatın özellikleri arasında, çiçek motifleri, insan figürleri ve çeşitli hayvanlar yer almaktadır. Bu dönemde, insan figürleri daha gerçekçi hale getirilmiştir ve detaylar daha ince bir şekilde işlenmiştir.</p><p>Gotik mimarisi, kiliseler, katedraller ve manastırlar için kullanılmıştır. Katedrallerde bulunan şapeller ve koro bölümleri, mimarinin önemli bir parçasıdır. Katedraller, sıradan kiliselerden daha yüksek ve daha zarif hatlara sahiptir. Genellikle vitray pencereleri ve diğer süslemelerle bezelidir.</p><p>Gotik heykel sanatı, kiliselerin iç ve dış dekorasyonunda sıklıkla kullanılmıştır. Heykeller, doğal boyutlarında veya daha büyük boyutlarda yapılırdı. Genellikle dini figürleri, azizleri veya diğer önemli dini figürleri tasvir ederdi.</p><p>Gotik resim sanatı, kiliselerin iç duvarlarını ve vitray pencerelerini süslemek için kullanılmıştır. Bu resimler, dini figürleri ve sahneleri tasvir ederdi. Sıklıkla anlatısal bir amaç taşırdı.</p><p>Gotik sanat ayrıca, sanatçıların doğal dünya ve insan ruhu hakkında daha fazla anlayışa sahip olmalarına neden olan Rönesans’a hazırlık dönemi olarak da kabul edilir. Bu dönemde, perspektif kullanımı da gelişmiştir. Gotik sanatın öne çıkan eserlerinden bazıları arasında, <strong>Notre-Dame Katedrali</strong>’ndeki vitray pencereler, <strong>Chartres Katedrali</strong>’ndeki merdivenli tonoz ve<strong> Strasbourg Katedrali</strong>’ndeki sütunlar bulunmaktadır. Ayrıca, Gotik sanatın en önemli heykeltraşlarından bazıları, Giovanni Pisano, Niccolò Pisano ve Claus Sluter’dir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/0*xz92wKo_WeUUl9jy" /><figcaption><strong>Strasbourg Katedrali</strong></figcaption></figure><p><strong>Notre-Dame Katedrali</strong>, Gotik dönemin en ünlü yapılarından biridir ve Paris’in sembolik bir simgesidir. Katedral, 1160&#39;larda inşa edilmeye başlanmış ve 1345&#39;te tamamlanmıştır. Fransa’nın Hristiyanlığa bağlılığını göstermektedir. Gotik mimarisinin en belirgin özelliklerini sergilemektedir. Yüksek ve zarif kemerleri, yivli sütunları, kemerli tonozları, detaylı kabartmaları ve vitray pencereleri ile dikkat çeken katedral, dönemin zenginliğinin ve gücünün bir sembolüdür. Katedralin en ünlü özelliği, batı cephesinde yer alan Rose pencereleri ve kuleleri ile doğu cephesindeki yedi kulesidir. Katedralin iç mekanı, şaşırtıcı bir yüksekliğe ve uzunluğa sahiptir. Duvarları detaylı bir şekilde işlenmiş kabartmalarla kaplıdır.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/768/0*FXZWpmwe7RG_KNII.jpg" /><figcaption><strong>Notre-Dame Katedrali</strong></figcaption></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=34ba96f749f3" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What is Unit Testing?]]></title>
            <link>https://medium.com/@kaaniince/what-is-unit-testing-7d6b4da8a7a6?source=rss-502e79383ac0------2</link>
            <guid isPermaLink="false">https://medium.com/p/7d6b4da8a7a6</guid>
            <category><![CDATA[unit-testing]]></category>
            <category><![CDATA[software-test-design]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[testing]]></category>
            <category><![CDATA[bug-detection]]></category>
            <dc:creator><![CDATA[Kaan Ince]]></dc:creator>
            <pubDate>Tue, 14 Mar 2023 22:55:44 GMT</pubDate>
            <atom:updated>2023-03-15T17:38:51.639Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>Unit testing</strong> is a testing technique that focuses on testing individual units of code such as functions and methods. It is considered the first level of testing, where the main focus is on the code itself. The purpose of unit testing is to ensure that each individual unit of code is functioning correctly, and that the code is working properly as a whole. This technique uses a <strong>white box</strong> approach, meaning that the source code is required for testing.</p><p>In unit testing, the database part is not considered, and the focus is solely on the <strong>functions </strong>and <strong>methods</strong>. The goal is to detect bugs and errors at an early stage, which can reduce the overall cost of development and maintenance. The types of bugs that should be detected include <strong>programming </strong>and <strong>design </strong>errors. However, the number and location of bugs are unknown.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*hd_vAirVpD6c8abV.png" /></figure><p>The materials required for unit testing include the source code and test data. The role of the tester is to find the most effective test data, which is data that is prone to failure and can detect bugs. The testing process relies on <strong>negative thinking</strong>, where the objective is to find <strong>failure-prone test data</strong>.</p><p>The unit testing process involves several steps, including test design, test execution, and test evaluation. In the test design phase, the tester selects the unit from the source code and generates a control flow graph of the selected unit. The tester then determines the test objective and criteria, such as coverage, and creates <strong>test requirements</strong>,<strong> test paths,</strong> <strong>test data</strong>, and <strong>desired output</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*_cF2xNieMch6pnWO.jpg" /></figure><p>During the test execution phase, the program is executed with the test data, and the tester reports the coverage and detected bugs. <strong>Node coverage</strong> and <strong>edge coverage</strong> are two additional terms that are used in unit testing.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uvbL6BopJs3hvtiiwBb1Sw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gm6921o9Q5V6HXbDj-qhSQ.png" /></figure><p>The article should cover the concepts of simple paths and prime paths in the context of unit testing. It should explain what these paths are, how they can be identified, and why they are important for creating effective unit tests. The article should also provide examples of how simple and prime paths can be used to improve the quality of unit tests and catch more bugs in code. Additionally, the article should discuss any limitations or challenges associated with using simple and prime paths in unit testing, and offer best practices for incorporating these techniques into a unit testing process.</p><p>In conclusion, unit testing is a critical step in the software development process that can help ensure the quality and reliability of the code. By identifying bugs and errors early on, unit testing can save time and reduce costs associated with software development and maintenance.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7d6b4da8a7a6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Introduction To Software Testing]]></title>
            <link>https://medium.com/@kaaniince/introduction-to-software-testing-d46c0dc016c6?source=rss-502e79383ac0------2</link>
            <guid isPermaLink="false">https://medium.com/p/d46c0dc016c6</guid>
            <category><![CDATA[software-testing]]></category>
            <category><![CDATA[testing]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Kaan Ince]]></dc:creator>
            <pubDate>Sun, 12 Mar 2023 22:01:55 GMT</pubDate>
            <atom:updated>2023-03-13T23:25:36.491Z</atom:updated>
            <content:encoded><![CDATA[<h3><strong>Testing Terminology</strong></h3><p>Software Faults,Errors and Failures</p><p><strong>Software Faults (bug) : </strong>A static defect in the software (by designer, developer etc. or in the database, algorithm etc.)</p><p>Syntax, semantic, and lexical bugs can usually be identified by the compiler. However, logical bugs may not be detected by the compiler and can cause unexpected behavior in the program. For example, using the minus symbol instead of the plus symbol in a section of code, or introducing an undesired condition in an “if” statement, can result in logical bugs that affect the program’s functionality. It’s important to carefully review and test code to identify and fix logical bugs before deploying the program.</p><p><strong>Software Error : </strong>An incorrect internal state that is the manifestation of some fault.</p><p><strong>Software Failure: </strong>External, incorrect behavior with respect to the requirements or other description of the expected behavior.</p><h3>Types Software Bug</h3><p>Coding Bugs (Lexical, Syntax and <strong>Logical</strong>) by developers.</p><p>Integration (Structural) Bugs</p><p>Data Bugs (in the code or database)</p><p>Design and Architecture Bugs</p><p>Requirements Bugs (These are the service areas of the project)</p><p>Quality Bugs (Performance,Security and etc.)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PYRrKHXTtfR1KwdT_-D0ag.png" /><figcaption>Causes of Software Bugs</figcaption></figure><p><strong><em>“There is no application without bugs”</em></strong></p><p><strong>Testing: </strong>Finding inputs that cause the software to fail. Testing is a crucial process in software development that aids in the detection of hidden or embedded bugs within an application.</p><p>By utilizing testing techniques, one can determine whether a program is functioning properly or not. Our objective is to accurately identify when a program is not working correctly through the application of these testing methods.</p><p><strong>Static and Dynamic Testing</strong></p><p>Static Testing is a type of testing that is performed without executing the program or the code. It is a technique used to inspect and review the code and other relevant documents, such as requirements, design specifications, and user manuals, to detect errors, omissions, or inconsistencies early in the development process. Static testing techniques can include code reviews, walkthroughs, and inspections.</p><p>Dynamic Testing, on the other hand, involves testing the software by executing the program with real inputs to evaluate its behavior and performance. It is a technique used to assess how the software performs in a real-world environment. Dynamic testing techniques can include functional testing, integration testing, performance testing, and security testing.</p><p>Both Static and Dynamic Testing are essential components of the software development lifecycle, and they complement each other in identifying different types of defects. Static Testing is effective in detecting issues related to code quality, such as coding standards violations, while Dynamic Testing is useful in identifying issues related to software functionality, performance, and security.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*3E7bj1mzm5XuSaQ-.jpg" /></figure><p><strong>Debugging: </strong>The process of finding a fault given a failure.</p><p>The testing stage is often considered more challenging than the debugging stage in software development, particularly when dealing with deep or complex code where the probability of encountering bugs is higher.</p><p>It is important to remember that when conducting tests, one must enter every stage of the code that was written specifically for testing purposes.</p><h3><strong>Test Case</strong></h3><p><strong>Test Case Values</strong> are the specific input values that are used in a test case to directly satisfy a particular test requirement. These values are carefully chosen to ensure that the test case covers a specific scenario or condition and that the software system behaves as expected under these conditions.</p><p>Test Case Values are selected based on the requirements of the test case and the expected behavior of the software system. They can include various types of data, such as numeric values, text values, special characters, and boolean values, among others. The selection of test case values is crucial in ensuring that the test cases are effective and efficient in detecting faults and errors in the software system.</p><p>During the testing process, test case values are inputted into the software system, and the results are compared against the expected outcomes to determine if the software system is functioning correctly. If the system behaves as expected, the test case is considered to be passed. However, if the system does not behave as expected, the test case is considered to have failed, and further investigation is required to identify and fix the issue.</p><p>In summary, Test Case Values are the specific input values that are chosen to satisfy the requirements of a test case, and they play a crucial role in ensuring the effectiveness and efficiency of the testing process.</p><p>Expected results refer to the outcome that is expected when a program or system is tested against a particular set of inputs or conditions. These results are based on the intended behavior of the program, as specified in its design or requirements.</p><p><strong>Expected Results</strong> are typically documented in a test plan or test case, which outlines the steps to be taken and the criteria to be met when executing a particular test. The expected results for a given test case will vary depending on the specific functionality being tested, as well as the inputs and conditions being evaluated.</p><p>In general, expected results should be specific, measurable, and observable. They should describe the outcome that is expected in terms of both the data produced by the program and any actions or behaviors that should be exhibited by the system.</p><p>For example, if testing a calculator program, an expected result might be that entering the equation “2+2” should produce the output “4”. Or, if testing a login system, an expected result might be that entering valid credentials should allow the user to access the system, while entering invalid credentials should result in an error message.</p><p>Overall, expected results are a critical component of software testing, as they provide a clear benchmark against which to evaluate the performance of a program or system. By identifying and documenting these outcomes in advance, developers and testers can ensure that the program meets the desired functionality and behaves as intended.</p><h3>Cost of Testing</h3><p>You’re goint to spend at least half of your development budget on testing. whether you want to or not.</p><h3>Types of Test Activities</h3><p>1- Test Design</p><p>2- Test Execution</p><p>3- Test Evaluation</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d46c0dc016c6" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>