<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>programming on Sadman Kabir Soumik</title>
    <link>https://blog.sksoumik.com/tags/programming/</link>
    <description>Recent content in programming on Sadman Kabir Soumik</description>
    <generator>Hugo -- gohugo.io</generator>
    <language>en</language>
    <copyright>Copyright © 2022, Sadman Kabir Soumik</copyright>
    <lastBuildDate>Fri, 19 Aug 2022 00:00:00 +0000</lastBuildDate><atom:link href="https://blog.sksoumik.com/tags/programming/index.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>Working with Elasticsearch on Linux Using Python Client</title>
      <link>https://blog.sksoumik.com/software-engineering/elasticsearch-python-client-tutorial/</link>
      <pubDate>Fri, 19 Aug 2022 00:00:00 +0000</pubDate>
      
      <guid>https://blog.sksoumik.com/software-engineering/elasticsearch-python-client-tutorial/</guid>
      <description>
        
          
            Elasticsearch Elasticsearch is a distributed, open-source search and analytics engine based on the Apache Lucene search library. It&#39;s designed to provide fast and scalable search and analysis capabilities for large volumes of data.
At its core, Elasticsearch is a document-oriented database that stores data in JSON format. This allows it to index and search through data quickly and efficiently. Elasticsearch uses a powerful query language called Elasticsearch Query DSL to perform complex search queries on this data.
          
          
        
      </description>
    </item>
    
    <item>
      <title>Keyphrase Extraction with BERT Embeddings and Part-Of-Speech Patterns</title>
      <link>https://blog.sksoumik.com/artificial-intelligence/keyphrase-extraction-techniques-with-bert-embeddings-pos-patterns/</link>
      <pubDate>Thu, 19 May 2022 00:00:00 +0000</pubDate>
      
      <guid>https://blog.sksoumik.com/artificial-intelligence/keyphrase-extraction-techniques-with-bert-embeddings-pos-patterns/</guid>
      <description>
        
          
            Keyphrases are important pieces of information that can be extracted from text documents. These are words or phrases that summarize the main ideas or topics of a text, and they can be useful for a variety of applications, such as document summarization, text classification, and information retrieval. In this blog post, we will explore how keyphrases can be extracted from text documents, and discuss some of the techniques and tools that can be used for this task.
          
          
        
      </description>
    </item>
    
    <item>
      <title>Python Collections Module Tutorial</title>
      <link>https://blog.sksoumik.com/software-engineering/tutorial-on-python-collections-module/</link>
      <pubDate>Fri, 23 Apr 2021 00:00:00 +0000</pubDate>
      
      <guid>https://blog.sksoumik.com/software-engineering/tutorial-on-python-collections-module/</guid>
      <description>
        
          
            Python&#39;s collections module implements specialized container datatypes providing alternatives to Python’s general purpose built-in containers, dict, list, set, and tuple.
This module has the following containers:
11. Counter() 22. namedtuple() 33. deque() 44. defaultdict() 55. OrderedDict() 66. UserDict() 77. UserString() 88. UserList() 99. ChainMap() In my experience, out of all of these modules Counter, defaultdict, OrderedDict, and deque are the most useful ones. The following section explains how Counter, defaultdict, OrderedDict, and deque works.
          
          
        
      </description>
    </item>
    
    <item>
      <title>Lambda, Map, Filter, and Reduce in Python</title>
      <link>https://blog.sksoumik.com/software-engineering/lambda-map-filter-reduce-python/</link>
      <pubDate>Fri, 11 Dec 2020 00:00:00 +0000</pubDate>
      
      <guid>https://blog.sksoumik.com/software-engineering/lambda-map-filter-reduce-python/</guid>
      <description>
        
          
            Lambda The Lambda function, also known as an anonymous or inline function, is a way to create a function without giving it a name. This can be useful when you need to define a function that will only be used once, or when you want to pass a function as an argument to another function.
Here is an example of using a Lambda function in Python:
1# Define a Lambda function that takes two arguments and returns their sum 2sum_func = lambda x, y: x + y 3 4# Call the Lambda function 5result = sum_func(1, 2) # Returns 3 Map The Map function in Python applies a function to each element in a sequence of data.
          
          
        
      </description>
    </item>
    
    <item>
      <title>Unleashing the Power of Bit Manipulation in Computer Science</title>
      <link>https://blog.sksoumik.com/software-engineering/bit_manupulation_in_python/</link>
      <pubDate>Fri, 12 Jun 2020 00:00:00 +0000</pubDate>
      
      <guid>https://blog.sksoumik.com/software-engineering/bit_manupulation_in_python/</guid>
      <description>
        
          
            Bit Manipulation Bit manipulation is a technique used in computer science to manipulate data at the level of its binary representation. This can be useful for a variety of tasks, such as low-level optimization, data compression, and cryptography.
At its core, bit manipulation involves working with individual bits, rather than larger units of data such as bytes or words. This is typically done using bitwise operators, which perform operations on the individual bits of a number.
          
          
        
      </description>
    </item>
    
    <item>
      <title>Different Text Cleaning Methods for NLP Tasks</title>
      <link>https://blog.sksoumik.com/artificial-intelligence/nlp-text-cleaning-methods-explained/</link>
      <pubDate>Mon, 04 May 2020 00:00:00 +0000</pubDate>
      
      <guid>https://blog.sksoumik.com/artificial-intelligence/nlp-text-cleaning-methods-explained/</guid>
      <description>
        
          
            Cleaning text for natural language processing (NLP) tasks is an important step that can help improve the performance of your model. In this blog post, we will discuss some common text cleaning techniques and how to apply them to your text data.
The first step in cleaning text for NLP is to remove any noisy or irrelevant information. This can include things like HTML tags, URLs, and other extraneous characters. Removing this information can help the model focus on the relevant content and improve its performance.
          
          
        
      </description>
    </item>
    
    <item>
      <title>Compiler vs Interpreter - A Simple Guide for Beginners</title>
      <link>https://blog.sksoumik.com/software-engineering/compiler-vs-interpreter-in-simple-terms/</link>
      <pubDate>Tue, 21 Jan 2020 00:00:00 +0000</pubDate>
      
      <guid>https://blog.sksoumik.com/software-engineering/compiler-vs-interpreter-in-simple-terms/</guid>
      <description>
        
          
            Imagine you’ve written a letter in English, but your friend only speaks Spanish. You’d need someone (or something) to translate it for them, right? In programming, your code is like that letter, and the computer only understands a special language called &amp;quot;machine language&amp;quot; (all 0s and 1s). A compiler and an interpreter are like translators that help the computer understand what you’ve written in languages like Python, C++, or Java.
          
          
        
      </description>
    </item>
    
    <item>
      <title>Dynamic Programming - Step by Step Guide with Examples</title>
      <link>https://blog.sksoumik.com/software-engineering/dynamic-programming-step-by-step-explanation/</link>
      <pubDate>Mon, 23 Dec 2019 00:00:00 +0000</pubDate>
      
      <guid>https://blog.sksoumik.com/software-engineering/dynamic-programming-step-by-step-explanation/</guid>
      <description>
        
          
            Dynamic programming is a method for solving complex problems by breaking them down into smaller subproblems. It is a mathematical optimization technique that is mainly used for solving problems that exhibit the properties of overlapping subproblems and optimal substructure.
The basic idea behind dynamic programming is to solve a complex problem by breaking it down into smaller subproblems, solving each of those subproblems just once, and storing their solutions. The solutions to the subproblems are then used to solve the original problem.
          
          
        
      </description>
    </item>
    
    <item>
      <title>Multi-Threading vs Multi-Processing</title>
      <link>https://blog.sksoumik.com/software-engineering/multi-threading_vs_multi-processing/</link>
      <pubDate>Sun, 24 Nov 2019 00:00:00 +0000</pubDate>
      
      <guid>https://blog.sksoumik.com/software-engineering/multi-threading_vs_multi-processing/</guid>
      <description>
        
          
            Let&#39;s say you&#39;ve got a big school project to do. You need to write a report, paint a picture, and build a model. Here&#39;s how you might tackle the project under different scenarios:
Multi-processing This is like having multiple copies of yourself, each working independently on a different part of the project. One of you is writing the report, another one is painting the picture, and the third one is building the model.
          
          
        
      </description>
    </item>
    
    <item>
      <title>Understanding Logarithm Function</title>
      <link>https://blog.sksoumik.com/software-engineering/understanding-logarithm-function-computer-science/</link>
      <pubDate>Tue, 06 Aug 2019 00:00:00 +0000</pubDate>
      
      <guid>https://blog.sksoumik.com/software-engineering/understanding-logarithm-function-computer-science/</guid>
      <description>
        
          
            Logarithms are mathematical operations that are the inverse of exponentiation. In other words, if we have a base b and an exponent x, the logarithm of the resulting number y to the base b is x. This can be written as log_b(y) = x.
For example, the logarithm of 1000 to base 10 is 3, because 10^3 = 1000. Similarly, the logarithm of 100 to base 10 is 2, because 10^2 = 100.
          
          
        
      </description>
    </item>
    
    <item>
      <title>Decorators in Python</title>
      <link>https://blog.sksoumik.com/software-engineering/decorators_in_python/</link>
      <pubDate>Mon, 20 May 2019 00:00:00 +0000</pubDate>
      
      <guid>https://blog.sksoumik.com/software-engineering/decorators_in_python/</guid>
      <description>
        
          
            Decorator is a design pattern to extend the functionality of a function without modifying the structure of the original function. Decorators are usually applied to functions using the @decorator syntax, immediately before the function definition.
Example of how to use a decorator to extend the functionality of a function:
1def my_decorator(func): 2 def wrapper(*args, **kwargs): 3 # Do something before the function is called 4 result = func(*args, **kwargs) 5 # Do something after the function is called 6 return result 7 return wrapper 8 9@my_decorator 10def add(x, y): 11 return x + y The add function is decorated with the my_decorator function.
          
          
        
      </description>
    </item>
    
    <item>
      <title>Understanding Dependency Injection - Real-World Examples and Advantages</title>
      <link>https://blog.sksoumik.com/software-engineering/dependency-injection-real-world-examples-advantages/</link>
      <pubDate>Sat, 10 Feb 2018 00:00:00 +0000</pubDate>
      
      <guid>https://blog.sksoumik.com/software-engineering/dependency-injection-real-world-examples-advantages/</guid>
      <description>
        
          
            Dependency injection is a design pattern that is widely used in software development to promote good software design and make code more flexible and easier to test. In this blog post, we will take a closer look at what dependency injection is, how it works, and its advantages.
What is Dependency Injection? Dependency injection is a technique that allows an object to receive its dependencies (other objects it needs to function) from the outside, rather than creating them itself.
          
          
        
      </description>
    </item>
    
  </channel>
</rss>
