C dilinde yazılan SQLite’ın diğer veritabanı dilleri gibi kendine özgü sentaksı vardır. Bu makalede SQLite nedir ve nasıl kullanılır hakkında genel bir bilgi sahibi etmeyi hedefledim.

Öncelikle Linux sistemimize sqlite kütüphanesini ekliyoruz:

sudo apt install sqlite3

# emin olmak icin calistirin: sqlite --version

Daha sonra dilediğimiz dizinde aşağıdaki komut vasıtasıyla veritabanımızı yaratıyoruz:

sqlite3 arabalar.db

# asagidaki gibi bir cikti almamiz gerek
# Output
# SQLite version 3.31.1 2020-01-27 19:55:54
# Enter ".help" for usage hints.
# sqlite> ... 

Veritabanları tıpkı Excel programında olduğu gibi satır ve sütunlardan oluşan bir tabloya benzer. Sütunlar verilerimizin sahip olmasını istediğimiz özelliklerdir (id, isim, adet vs). Tablo yaratmak için kullanılan komut CREATE TABLE komutudur. Mesela arabalar veritabanımıza id, marka, model ve kilometre bilgilerini verdiğimiz bir örnek yaratalım:

CREATE TABLE arabalar(id integer NOT NULL, marka text NOT NULL, model text NOT NULL, kilometer integer NOT NULL);

ifadelerin yanındaki NOT NULL ifadesi o özelliği required yapar. Yani daha sonra o parametre boş bırakılamaz. Ek olarak, SQLite büyük-küçük harf ayrımı yapmaz — yani CREATE ile create aynı şekilde çalışır fakat geleneksel olarak veritabanları sorgularında büyük harf kullanılır.

Bununla beraber yorum satırı için (--) kullanılır:

sqlite> -- bu bir yorum satiri

Eğer ki aynı isimde bir tablo olduğundan şüphelenirseniz:

CREATE TABLE IF NOT EXISTS ...

Tablomuz yaratıldı fakat şuan için boş. Bunları doldurmayı görelim. Bunun için de INSERT INTO komutu kullanılır:

INSERT INTO arabalar VALUES (1, "Opel", "Corsa", 10500);
INSERT INTO arabalar VALUES (2, "Honda", "City", 26000);
INSERT INTO arabalar VALUES (3, "Peugeot", "507", 50000);
INSERT INTO arabalar VALUES (3, "Peugeot", "507"); # hata verir

Artık verileri eklendi. Şimdi bir veritabanındaki bütün verileri okumayı sağlayan SELECT * FROM __ komutunu inceleyim:

SELECT * FROM arabalar;

(*) ifadesi ReGex notasyonundan alışık olduğumuz üzere her şeyi kapsar. Sonuç şu olur:

sqlite> SELECT * FROM arabalar;

1|Opel|Corsa|10500
2|Honda|City|26000
3|Peugeot|507|50000

Yukarıdaki şekil varsayılandır. Bunu özelleştirmek isterseniz

sqlite>.header on
sqlite>.mode column

diyerek güzelleştirebilirsiniz:

id  marka    model  kilometer
--  -------  -----  ---------
1   Opel     Corsa  10500    
2   Honda    City   26000    
3   Peugeot  507    50000  

İstediğiniz kadar sonuç almak isterseniz:

SELECT * FROM arabalar LIMIT 10 -- ilk 10 sonuç gelir

Eğer sonuçları alırken filtreleme yapmak istiyorsanız WHERE komutunu kullanmalısınız:

SELECT * FROM arabalar WHERE kilometer > 20000;

id  marka    model  kilometer
--  -------  -----  ---------
2   Honda    City   26000    
3   Peugeot  507    50000   

gördüğünüz gibi 1 numaralı girdinin kilometer verisi (>20000) şartını sağlamadığı için sorgulamaya dahil edilmedi. Eğer ki kesin bir filtreleme yapmak istiyorsanız IS kalıbını kullanabilirsiniz:

SELECT * FROM arabalar WHERE id IS 3

Başlarken sütunların verilerin özelliklerini belirttiğini söylemiştik. Şimdi yeni özelliklerin nasıl eklenip çıkarılabileceğine bakalım:

ALTER TABLE arabalar ADD COLUMN renk text;

Aralık belirtmek isterseniz:

SELECT * FROM arabalar WHERE kilometer BETWEEN 20000 and 30000

Eğer ki var olan verilerinizi güncellemek isterseniz UPDATE komutunu kullanmanız gerekir:

UPDATE arabalar SET renk = 'siyah' WHERE id=1;
UPDATE arabalar SET renk = 'gri' WHERE id=2;
UPDATE arabalar SET renk = 'beyaz' WHERE id=3;

Eğer stringlerle uğraşıyorsanız ve belirli bir patern arıyorsanız:

SELECT * FROM arabalar WHERE marka GLOB 'peu*' ORDER BY id ASC;

bu durumda marka bilgisi peu ile başlayan tüm satırlar gelecektir.

Verileri özelleştirirken ORDER BY komutuyla sıralayabilirsiniz:

SELECT * FROM arabalar ORDER BY id DESC;

id  marka    model  kilometer
--  -------  -----  ---------
3   Peugeot  507    50000    
2   Honda    City   26000    
1   Opel     Corsa  10500  

SELECT * FROM arabalar ORDER BY kilometer ASC;

id  marka    model  kilometer
--  -------  -----  ---------
1   Opel     Corsa  10500    
2   Honda    City   26000    
3   Peugeot  507    50000   

Programlama dillerinden aşina olduğumuz mantık operatörleri AND ve OR da benzer şekilde kullanılır:

SELECT
  name,
  surname
FROM
  persons
WHERE
  name = 'bugra'
  OR surname = 'kara'

Veritabanından girdi silmek isterseniz DELETE komutunu kullanabilirsiniz (! veritabanı sıfırlanır):

DELETE * FROM arabalar

Birden çok veriyi filtreleyerek silmek isterseniz DELETE komutunu özelleştirebilirsiniz:

DELETE FROM arabalar WHERE kilometer <= 30000;

Son olarak, veritabanından spesifik bir tablo silmek isterseniz DROP kullanırsınız:

DROP TABLE arabalar

eğer tabloların listesini görmek isterseniz:

sqlite>.tables
arabalar

SQLite yukarıdakilerin haricinde daha birçok komut içeriyor ama genel bir taslak çizmek adına bu makaleyi yazma gereği duydum. İyi programlamalar!

These days I’ve been wrestling with my Flutter app to implement the best looking onboarding pages flipping through the endless realm of internet. Then I came across a pub.dev package that fixed all my problems - thanks to appinio. This package comes all-set and all you need to do is minor configurations.

I will, in layman’s terms, try to explain the way you can implement it in your Flutter app. Let’s see how:

As it is the case with all flutter packages, you must start by adding the package in your pubspec.yaml — the easier way (and the I always choose) is using terminal for that:

flutter pub add flutter_onboarding_slider

This will automatically run pub get and pub upgrade. Then, you must import it in the file you are going to use:

import 'package:flutter_onboarding_slider/flutter_onboarding_slider.dart';

Preparations done! All that is left is to implement the class of Onboarding:

class MyHome extends StatelessWidget {
  final Color myChosenColor = const Color(0xFF053149);

  const MyHome({super.key});

  @override
  Widget build(BuildContext context) {
    return OnBoardingSlider(
      // the button that'll pop when sliding is done
      finishButtonText: 'Register',
      onFinish: () {
        Navigator.push(
          context,
          CupertinoPageRoute(
            builder: (context) => const RegisterPage(),
          ),
        );
      },
      finishButtonStyle: FinishButtonStyle(
        backgroundColor: myChosenColor,
      ),
      skipTextButton: Text(
        'Skip',
        style: TextStyle(
          fontSize: 16,
          color: myChosenColor,
          fontWeight: FontWeight.w600,
        ),
      ),
      trailing: Text(
        'Login',
        style: TextStyle(
          fontSize: 16,
          color: myChosenColor,
          fontWeight: FontWeight.w600,
        ),
      ),
      trailingFunction: () {
        Navigator.push(
          context,
          CupertinoPageRoute(
            builder: (context) => const LoginPage(),
          ),
        );
      },
      controllerColor: myChosenColor,
      totalPage: 3,
      headerBackgroundColor: Colors.white,
      pageBackgroundColor: Colors.white,
      background: [
        // these are the background images for each page
        Image.asset(
          'assets/slide_1.png',
          height: 400,
        ),
        Image.asset(
          'assets/slide_2.png',
          height: 400,
        ),
        Image.asset(
          'assets/slide_3.png',
          height: 400,
        ),
      ],
      speed: 1.8,
      pageBodies: [
        Container(
            // content of page1
            ),
        Container(
            // content of page2
            ),
        Container(
            // content of page3
            ),
      ],
    );
  }
}

Onboarding class has a lot more to it in case you would opt to use them, a few examples being:

  OnBoardingSlider({
    required this.totalPage,
    required this.headerBackgroundColor,
    required this.background,
    required this.speed,
    required this.pageBodies,
    this.onFinish,
    this.trailingFunction,
    this.trailing,
    this.skipTextButton,
    this.pageBackgroundColor,
    this.pageBackgroundGradient,
    this.finishButtonStyle,
    this.finishButtonText,
    this.controllerColor,
    this.addController = true,
    this.centerBackground = false,
    this.addButton = true,
    this.imageVerticalOffset = 0,
    this.imageHorizontalOffset = 0,
    this.leading,
    this.middle,
    this.hasFloatingButton = true,
    this.hasSkip = true,
    this.finishButtonTextStyle = const TextStyle(
      fontSize: 20,
      color: Colors.white,
    ),
    this.skipIcon = const Icon(
      Icons.arrow_forward,
      color: Colors.white,
    ),
    this.indicatorAbove = false,
    this.indicatorPosition = 90,
    this.skipFunctionOverride,
  });

These are all the features that OnboardingSlider package allows you to use

That was it for this article. See you in another one!

Sıcaklıkların 40 dereceyi aştığı, her üç dakikada bir telefona girip hava durumuna baktığım bu kavurucu yaz günlerinde kendi hava durumu uygulamamı (Weatherly) yazmaya karar verdim. API & Json Handling temeller bilindiği müddetçe öğrenmesi ve uygulaması gayet kolay mekanizmalar fakat ilk kullanımda karmaşık gelebiliyor. Bu makalede bulduğum birbirinden güzel ücretsiz ve Türkçe API kaynaklarından ve basit düzeyde nasıl kullanılacağından bahsetmeye çalışacağım.

Uzun uğraşlar sonucu denk geldiğim https://collectapi.com/tr/ sitesinde karar kıldım. İçerisinde birbirinden güzel ve herkesin ilgisine hitap edebilecek alanlarda API’ler mevcut. Özellikle indie geliştiriciyseniz 7$ (10.000 req/mo) ve 49$ (200.000 req/mo) gibi premium paketlere ihtiyaç duymaksızın ayda 2500 request hakkı veren ücretsiz versiyonuyla portfolyönüze gayet güzel uygulamalar/websiteleri çıkartabilirsiniz. Unutmadan, API anahtarınıza erişebilmek için üye olmanız gerekiyor

Seçtiğim hava durumu API’si 7 günlük hava durumu tahmini, güncel tarihler, minimum/maksimum sıcaklıklar, nem oranı ve daha birçok farklı bilgiyle geliyor. Ayrıca farklı dillerde request atabilme seçeneğiniz de var. Fakat her halükarda API’ye hava durumu verilerini almak istediğiniz şehrin adıyla erişebiliyorsunuz. Bunun için şöyle bir yol izledim:

1. Fiziksel konumumu enlem/boylam olarak aldım
2. Her şehrin enlem/boylam bilgilerinin key-value halinde tutulduğu bir map yarattım
3. Bu enlem/boylam verilerinden anahtara yani şehrin adına ulaşıp API çağrımı gerçekleştirdim

Her şeyden önce uygulamamda cihazımın fiziksel konumu almak için izin istemek zorundaydım. Bunu android/app/src/main dizininde bulunan AndroidManifest.xml üzerinden yapıyorsunuz:

    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
    <uses-permission android:name="android.permission.INTERNET" />

FINE_Location burada hassas konumunuzu, COARSE_Location ise yaklaşık konumunuzu hesaplıyor.

İzinleri aldıktan sonra konumumu bulacak fonksiyonu yazdım. Bu fonksiyon Geolocator paketini kullanıyor:

Future<void> _getCurrentLocation() async {
    try {
      LocationPermission permission = await Geolocator.requestPermission();

      if (permission == LocationPermission.denied) {
        setState(() {
          _currentLocation = 'İzin Verilmedi';
        });
        return;
      }

      Position position = await Geolocator.getCurrentPosition(
          desiredAccuracy: LocationAccuracy.high);
      List<Placemark> placemarks =
          await placemarkFromCoordinates(position.latitude, position.longitude);

      String? location;

      String placemarksStr = placemarks.toString();
      List<String> words = placemarksStr.split(' ');

      for (int i = 0; i < words.length; i++) {
        words[i] = words[i].toLowerCase().replaceAll(',', '');
      }

      for (String word in words) {
        String lowercaseWord = word.toLowerCase();

        if (_cities.contains(lowercaseWord)) {
          location =
              _cities.firstWhere((city) => city.toLowerCase() == lowercaseWord);
          break;
        }
      }

      if (location != null && location.isNotEmpty) {
        setState(() {
          _currentLocation = location;
        });
      } else {
        setState(() {
          _currentLocation = 'Unknown';
        });
      }
    } catch (e) {
      setState(() {
        _currentLocation = 'Error getting location';
      });
    }
    _getLongLat(_currentLocation);
  }

Enlem/boylam bilgilerim sayesinde bulunduğum şehri öğrendikten sonra API çağrımı yapabilecek hale gelmiştim:

Uri.parse('https://api.collectapi.com/weather/getWeather?data.lang=tr&data.city=$locationn')

Fakat sadece fiziksel konumun hava durumunu öğrenmenin yetersiz kalacağını düşündüğümden bunu 81 şehirle genişlettim:

Map<String, LatLng> coordinates = {
  "Adana": const LatLng(37.0, 35.3213),
  "Adıyaman": const LatLng(37.7648, 38.2765),
  "Afyonkarahisar": const LatLng(38.756, 30.543),
  "Ağrı": const LatLng(39.7217, 43.0567),
  "Aksaray": const LatLng(38.3687, 34.037),
  "Kahramanmaraş": const LatLng(37.5833, 36.9333),
  "Karabük": const LatLng(41.2, 32.6333),
  "Karaman": const LatLng(37.1759, 33.2287),
  "Kars": const LatLng(40.5927, 43.0772),
  "Kastamonu": const LatLng(41.3887, 33.7827),
  "Kayseri": const LatLng(38.737, 35.4977),
  "Kırıkkale": const LatLng(39.8578, 33.5109),
  "Kırklareli": const LatLng(41.7333, 27.2167),
  "Kırşehir": const LatLng(39.1458, 34.1638),
  "Kilis": const LatLng(36.716, 37.115),
  "Kocaeli": const LatLng(40.8533, 29.8815),
  "Konya": const LatLng(37.8664, 32.4922),
  "Kütahya": const LatLng(39.4214, 29.9838),

  [...]

};

Daha sonra yazdığım AlertDialog ile bu şehirlerden herhangi birini seçen kullanıcı artık o şehrin hava durumunu görebiliyordu.

İki şekilde de alabildiğim şehir bilgisiyle yaptığım API çağrısı bana Json formatında uzun bir response body döndürdü.

{
  "success": true,
  "city": "ankara",
  "result": [
    {
      "date": "13.06.2024",
      "day": "Perşembe",
      "icon": "https://cdnydm.com/permedia/LC1i84c3Z2MtLUDNbzWz8A.png?size=512x512",
      "description": "açık",
      "status": "Clear",
      "degree": "33.85",
      "min": "20.59",
      "max": "34.43",
      "night": "23.85",
      "humidity": "25"
    },
    {
      "date": "14.06.2024",
      "day": "Cuma",
      "icon": "https://cdnydm.com/permedia/zvWjzjmkp5WUUEWob4d48Q.png?size=512x512",
      "description": "şiddetli yağmur",
      "status": "Rain",
      "degree": "31.12",
      "min": "17.87",
      "max": "33.47",
      "night": "18.3",
      "humidity": "29"
    },
   
    [...]

  ]
}

Şimdi asıl iş bu json’dan ekranda görüntülenecek verileri çekmeye yani Json Parsing’e gelmişti:

Map<String, dynamic> jsonMap = json.decode(_apiResponse!);

 if (jsonMap.containsKey('result') && jsonMap['result'].isNotEmpty) {
        Map<String, dynamic> firstResult = jsonMap['result'][0];

        setState(() {
          currentWeather.date = firstResult['date'] ?? '';
          currentWeather.day = firstResult['day'] ?? '';
          currentWeather.icon = firstResult['icon'] ?? '';
          currentWeather.description = firstResult['description'] ?? '';
          currentWeather.status = firstResult['status'] ?? '';
          currentWeather.degree = firstResult['degree'] ?? '0';
          currentWeather.night = firstResult['night'] ?? '0';
          currentWeather.humidity = firstResult['humidity'] ?? '';

          _currentDegree = double.parse(currentWeather.degree).toInt();
          currentWeather.date = formatDate(currentWeather.date);
        });
      } else {
        throw Exception('Invalid response structure');
      }
}

Yazdığım parsing fonksiyonuyla verileri de başarıyla çektikten sonra tek iş tasarımı ve temayı halletmek oldu:

Kaynak kodlarını girişte paylaştığım bu uygulama basit de olsa API kullanımı hakkında bir çerçeve çiziyor. Şimdilik bu kadar, görüşmek üzere!

First things first, Make is a script automatization technique invented by Stuart Feldman back in 70’s when working at Bell Labs. Just as Fertile Crescent is seen as the cradle of civilizations, Bell Labs is the cradle of computer science. UNIX (which will later be Torvald’s inspirer), C/C++ are all inventions of people from there. It is used in UNIX environments (Linux&Mac).

Make comes built-in in UNIX and here is how to check your Make version

make -v 

GNU Make 4.3
Built for x86_64-pc-linux-gnu
Copyright (C) 1988-2020 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.

It is primarily used to compile (mostly) C/C++ source codes en masse and generating an output file. Compiling a C/C++ file is normally quite easy with mere use of terminal

gcc -Wextra main.c -o main

But what if we need to compile dozens of .c file if not hundreds at once? Writing the name of each file is of course not the way to go, so here we are aided by Makefiles. Let’s compile our main.c file using makefile .

Example One — Basics

First we need to create a file called Makefile, makefile or GNUmakefile. All three will be seen as a valid makefile by your OS but ‘Makefile’ is almost always used. You can use make -f command to choose any other file as your makefile but that is way too detail. Our makefile will suffice to look like this

CC = gcc # fun fact! if you don't specify, default compiler is cc

all: program

program: main.c
 ${CC} main.c -o program # this line is the purpose of the whole file

clean:
 rm -rf program

Let’s analyze our makefile

• We have avariableCC . Lines used with (=) operator are called variables in a makefile. It’ll later be enough to say ${CC} (or $(CC) or $CC) to mean ‘gcc’.
• We have also commands. Lines used with (:) are called commands. They will later be used with command make to execute different sorts of execution blocks. What you write after a command is called dependency. A dependency, by its nature, is bound to its command. Make makes sure the dependency(ies) of a command is executed before executing the command itself. In our example, command programis executed before running command all. Similarly, command program is executed only after Make checks a) there is a file named main.c b) there are some changes in this main.c. This solves a problem called relink , which I will later dive into.
• Command clean works when user wants to clean the main.out file and go back to the initial status of the project.

If you want to execute a certain command, type it after keyword Make. i.e:
make clean
make myCommand …
! just saying <make> always executes automatically <make all> !

Then, we need to put our main.c file in the same directory, ready to be compiled with the command make.

Example Two —Multiple Files

Imagine we have three .c files:

• main.c

int main()
{
 printf("%d\n", ft_strlen("bugra"));
 ft_putchar('c');
 ft_putchar('\n');
}

• file1.c

int ft_strlen(char *str)
{
 int i = 0;
 while (str[i])
  i++;
 return i;
}

• file2.c

void ft_putchar(char c)
{
 write(1, &c, 1);
}

Now, normally — we’d compile these like

gcc file1.c file2.c main.c -o program

But no need for verbosity when makefiles are cut out tools for the job

CC = gcc

CFLAGS = -Wall -Werror

all: program

program: main.c file1.c file2.c
 $(CC) main.c file1.c file2.c -o program

clean:
 rm -f program

The gist of above makefile is the indirectional command hierarchy and dependencies. By declaring main.c, file1.c and file2.c as dependencies for the command program, we are avoiding what is called relink, which occurs when users are able executemake again and again though no changes made in the files — which is something we don’t want. By building an indirectionate relation, changes are always checked before execution of main make command.

Example Three - Source Files under a Variable

By fetching source files from a directory, we don’t have to write name of each file

CC = gcc

SRC_DIR = src

# directory where .o files will be extracted to
OBJ_DIR = obj

SRC_FILES = $(wildcard $(SRC_DIR)/*.c)
# or you could say
# SRC_FILES = $(shell ls $(SRC_DIR)/*.c)

OBJ_FILES = $(patsubst $(SRC_DIR)/%.c, $(OBJ_DIR)/%.o, $(SRC_FILES))

all: program

program: $(OBJ_FILES)
 $(CC) -o program $(OBJ_FILES)
 @echo "\033[32mCompiled ✅\033[0;37m"


# -p means ignore parent directory if extant
$(OBJ_DIR)/%.o: $(SRC_DIR)/%.c
 mkdir -p $(OBJ_DIR)
 $(CC) -c $< -o $@

clean:
 @echo "\033[0;31mCleaning objects🧹"
 rm -rf program $(OBJ_DIR)
 
fclean: clean
 @echo "\033[0;31mRemoving $(NAME) 🗑\033[0;37m"

Let’s analyze this makefile

• We first defined two directories : SRC_FILES, from which to take source files and OBJ_DIR, in which the .out files will be written
• $(OBJ_DIR)/%.o : puts all files ending with .o in the OBJ_DIR/ directory
• $< -o $@ : these are called automatic variables and are used as shortcuts. For instalce $< refers to the first dependency in the rule and $@ to the target of the file, in here program

# most important automatic variables in makefile are below
$@  denotes the target (file that rule updates or creates)
$<  denotes the first dependency of a rule
$^  denotes all the dependencies of a rule
$?  denotes all the dependencies newer than the target

Example Four - Phony

We also have another conventional feature: phony

CC = gcc

CFLAGS = -Wall -Werror

all: program

program: main.c file1.c file2.c
 $(CC) main.c file1.c file2.c -o program

clean:
 rm -f program

.PHONY: all clean

We said that using make with a command name executes that spesific command. But what if user has a file with the same name of one of the commands? That’s what phony exists for. By adding this line, you can safely use make all and make clean without worrying there are files with such names

Example Five — Conditions

You can also use conditions in your makefile for spesific situations

CC = gcc

CFLAGS = -Wall

SRC_DIR = src

INC_DIR = include

OBJ_DIR = obj

# if it is debugged, compile with -g flag
DEBUG ?= 0
ifeq ($(DEBUG), 1)
    CFLAGS += -g
 @echo asdasdasd
endif

SRC_FILES = $(wildcard $(SRC_DIR)/*.c)

OBJ_FILES = $(patsubst $(SRC_DIR)/%.c, $(OBJ_DIR)/%.o, $(SRC_FILES))

all: program

program: $(OBJ_FILES)
 $(CC) -o program $(OBJ_FILES)

$(OBJ_DIR)/%.o: $(SRC_DIR)/%.c
 mkdir -p $(OBJ_DIR)
 $(CC) -I$(INC_DIR) -c $< -o $@

clean:
 rm -rf program $(OBJ_DIR)

fclean: clean
 rm -rf program

If user decides to use this makefile under debug mode, he should say

make DEBUG=1

Example Six — Implicit Rules

Implicit rules are rules that you imply the make to do the job by setting predefined dependencies and targets, all without writing user-defined, explicit rules

CC = gcc

SRCS = main.c file1.c file2.c

OBJS = $(SRCS:.c=.o)

all: program

program: $(OBJS)
 $(CC) $(OBJS) -o program

# that is implicit rule
%.o: %.c
 $(CC) -c $< -o $@

re: clean all

clean:
 rm -f program
 rm -f *.o

That way makefile automatically generates .o files from .c files without user having to write a compiling command

Example Seven — Wildcards

You can use a keyword called wildcard that will comprehense your multiple files at once

SRCS = main.c file1.c file2.c # ya da
SRCS = $(wildcard *.c) 

OBJS = $(SRCS:.c=.o)

all: program

program: $(OBJS)
 $(CC) $(OBJS) -o program

%.o: %.c
 $(CC) -c $< -o $@

re: clean all

# mesela *.o demek .o ile bütün her şey demektir
clean:
 rm -f *.o

That way it will count all the files that end with .c. This is actually a bash technique frequently used with makefiles for it makes things much easier and code less shorter.

There are still hundreds of more features and details to these, these are just what I generally use if I can’t convince AI to write a makefile for me. Here is my makefile notes and in it you’ll find some (probably much better) sources I benefited for this article

my notion notes on makefile

my other notes about CS

bye!

There are two rival UI components in Android: ListView and RecyclerView. Both are used to display scrollable list items. While mainly similar, there are some critic differences.

Though relatively harder to implement, RecyclerView is usually preferred when it comes to performance issues. The other, on the other hand, is opted when dealing with smaller and primitive data sets.

I will try to elaborate on the points they diverge and plainly explain how they are implemented, especially with built-in vs. custom parameters. I will use Kotlin as the language. Here are some differences

The keystone is to keep in mind the fact that RecyclerView is costly, yet the efficient one.

Now, let’s see their implementations.

To implement a ListView with a built-in data type parameter (like a List<String,Integer,Double> etc.), you need only the listView widget and a layout file, nothing else.

First, place the ListView component in your activity/fragment:

# activity_layout.xml

<ListView
        android:id="@+id/list_view"
        android:layout_width="match_parent"
        android:layout_height="match_parent" />

We also need to create a layout file in res/layout that will symbolize a single item

# list_view.xml 

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:padding="15dp">

    <TextView
        android:id="@+id/color_textview"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="COLOR"
        android:textAlignment="center"
        android:textSize="24sp" />

</RelativeLayout

Then, in our, let’s say Activity, implement it

// MainActivity.kt 

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // we can create an array whose items will be listed
        val colors = listOf("red", "purple", "pink", "white", "cyan")
        
        // here we need an adapter variable. simple_list_item_1
        val listAdapter = ArrayAdapter(this, android.R.layout.simple_list_item_1, colors)

        val list_view = findViewById<ListView>(R.id.list_view)
        list_view.adapter = listAdapter
        // list_view.setAdapter(listAdapter) // alternatively

        list_view.setOnItemClickListener { parent, view, position, id ->
            val selected_item = listAdapter.getItem(position)
            Toast.makeText(this, "You clicked ${selected_item}.", Toast.LENGTH_SHORT).show()
        }
    }
}

and these steps suffice to display a most-basic list of items

Pretty simple, isn’t it? Now let’s dive into the realm of custom classes. We now shall use a custom class, say a User class, to list in our list view. Generally, bear in mind that if you are going to use a list whose items are sophisticated, that is, storing multiple properties — you would and should use RecyclerView. Yet, here is how to implement it with ListView.

Unlike simple data types, you will have to implement two more features to use your custom class: The class and an Adapter. First you need to create the class itself. Our example has a name and age property.

// User.kt

data class User(val name: String, val age: Int)

Then, likewise before, create a layout file so that you will decide how to locate and use each property in a single item row

# list_row.xml 

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"> // this is crucial

    <TextView
        android:id="@+id/user_name"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:padding="10dp"
        android:text="NAME"
        android:textAlignment="center"
        android:textSize="24sp"
        android:textStyle="bold" />

    <TextView
        android:id="@+id/user_age"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_toRightOf="@id/user_name"
        android:padding="10dp"
        android:text="AGE"
        android:textAlignment="center"
        android:textSize="24sp" />

</RelativeLayout>

Now it’s time you created the UserAdapter. It will be used when you create&bind each item from your source right into your list.

// UserAdapter.kt 

class UserAdapter(context: Context, users: List<User>) :
    ArrayAdapter<User>(context, R.layout.list_row, users) {
    override fun getView(position: Int, convertView: View?, parent: ViewGroup): View {
        var view = convertView
        val viewHolder: ViewHolder // you should use viewHolder for user-defined data types

        if (view == null) {
            view = LayoutInflater.from(context).inflate(R.layout.list_row, parent, false)
            viewHolder = ViewHolder()
            viewHolder.nameTextView = view.findViewById(R.id.user_name)
            viewHolder.ageTextView = view.findViewById(R.id.user_age)
            view.tag = viewHolder
        } else {
            viewHolder = view.tag as ViewHolder
        }

        // current user to be displayed on the list
        val user = getItem(position)
        // and its properties
        viewHolder.nameTextView?.text = user?.name
        viewHolder.ageTextView?.text = ", ${user?.age} years old."

        return view!!
    }

    // ViewHolder pattern for efficient view recycling
    private class ViewHolder {
        var nameTextView: TextView? = null
        var ageTextView: TextView? = null
    }
}

Finally in your activity/fragment, use it like

// MainActivity.kt

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        val list_view = findViewById<ListView>(R.id.list_view)

        val user_list = listOf<User>(
            User("Edward", 22),
            User("John", 11),
            User("Constable", 46)
        )

        // creating & setting the adapter 
        val list_adapter = UserAdapter(this, user_list)
        list_view.setAdapter(list_adapter)

        list_view.setOnItemClickListener { parent, view, position, id ->
            val selected_item = user_list[position]
            /* do what you gonna d- */
        }

        list_view.setOnItemLongClickListener { parent, view, position, id ->
            val selected_item = user_list[position]
            /* do what you gonna d- */
            false
        }
    }
}

Here is the outcome:

This was the core of ListViews. Now I will explain RecyclerViews with a custom class implementation. Let’s once again suppose we have list of type User (List<User>) and we want to display content of this list. We ought to

• Create the User class

data class User(private val name, private val age)

• Create UserAdapter, implement its member methods

class UserAdapter(private val userList: List<User>) :
    RecyclerView.Adapter<UserAdapter.UserViewHolder>() {

    class UserViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView) {
        val nameTextView: TextView = itemView.findViewById(R.id.nameTextView)
        val ageTextView: TextView = itemView.findViewById(R.id.ageTextView)
    }

    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): UserViewHolder {
        val itemView = LayoutInflater.from(parent.context)
            .inflate(R.layout.user_item, parent, false)
        return UserViewHolder(itemView)
    }

    override fun onBindViewHolder(holder: UserViewHolder, position: Int) {
        val currentUser = userList[position]
        holder.nameTextView.text = currentUser.name
        holder.ageTextView.text = currentUser.age.toString()
    }

    override fun getItemCount(): Int {
        return userList.size
    }
}

• In Activity create and populate a list of User

val users = listOf(User("Bugra", 25), User("Cemre", 30), "Ugur", 22))

• Finally, bind the list with our RecyclerView widget via adapter

val adapter = UserAdapter(users)
recyclerView.adapter = adapter

With these steps, we have completed the implementation of our RecyclerView with our custom class. Becomes pretty plain once you familiarize yourself over repetitive exercises. See you in the next article 👋

However, the concept started forming earlier, around the 1950's. Its roots can be traced back to John McCarthy who invented the LISP programming language. Though not technically the same, LISP set the ground for the emerge of modern-day OOP. The first closest language in the real sense was Simula, developed by Ole-Johan Dahl and Kristen Nygaard. Up until ’90s, the %99 of the programs in the world was procedural. Then came the famous modern-languages like C++, Java, C#, Python and JavaScript which all share the notion of OOP. It first came as an alternative to the existing paradigms like procedural programming (like C) where there is a strict linear flow of code or functional programming (like Haskell) that treats computation as the evaluation of mathematical functions. OOP then became immeasurably popular. For many experts, it still holds its lasting currency in the programming world.

OOP is basically the way of writing code with classes and objects that symbolize single units that are only meaningful in relation to one another. It harmonises programming with real-life concepts. It stands on the shoulders of four fundamental concepts:

1. Polymorphism → the idea of having multiple forms of a method. To understand it better, we shall think of an Animal Kingdom. Though every animal inherits from at least one Base class (Animal-ness), they all must have their unique features as well. Cats meow, lions roar, fish — well, they just swim. Therefore, the programmer must find a way to do some specializations for each one of them accordingly. Overriding the methods to change the morphology in each of these derived classes is called polymorphism.
2. Abstraction → the idea of hiding unnecessary information from the user. Imagine you are driving a car. Unless you are a qualified mechanic or a keen hobbist, most people just need to know about a handful of information in order to drive. You don’t need to know about the engineering of your tires or the mathematical calculations of your fuel use — these are hidden from you. That is abstraction in a nutshell — which itself, is nutshell-ing.
3. Encapsulation → the idea of combining the attributes and methods in a single unit, namely your class. Think of a big library. Suppose all single books are either data members or methods but when encapsulated together, they create another entity — the library. Encapsulation also allows you to decide on the secrecy of your books. Some of them are accessable by anyone (public), some only allowed for the students (protected) and some only within the reach of the librarian (private).
4. Inheritance → the idea of transferring information from an older class to the newly-created ones. Imagine the aforementioned animal kingdom (that being your base class) and many different species under it (all the derived classes). They all inherit from your Animal class, literally. That means they have all the information that their parent has but they may have their own features (methods) as well.

these are merely shallow definitions to familiarize newcomers with the basic concepts of OOP. now let’s see each in code to get the gist of them!

1) POLYMORPHISM

a. compile-time polymorphism:

a1. Function Overloading: It allows us to rewrite a method in the same scope with the same name as long as their return types and/or parameter(s) are not identical.

class Base {
  public:
    void fun(int a) {
      std::cout << "this is " << a << std::endl;
    }
    void fun(float b) {
      std::cout << "this is " << b << std::endl;
    }
};

int main() {
  Base base;

  base.fun(53);
  base.fun(2.99);
}

a2. Operator Overloading: It allows us to rewrite an operator so that they might gain extra features

class Deneme {
 public:
  int val;

  Deneme() {
   val = 5;
  }
  
  void operator--() {
   val = val - 3;
  }
};

int main() {
 Deneme deneme;
 --deneme;
 std::cout << deneme.val << std::endl; // 2
}

b. run-time polymorphism

b1. Function Overriding: It is termed as the redefinition of base class function in its derived class with the same signature i.e. return type and parameters.

class Base {
  public:
    void func() {
      std::cout << "this is base func" << std::endl;
    }
};

class Derived : Base {
  public:
    void func() {
      std::cout << "this is derived func" << std::endl;
    }
};

int main() {
  Derived derived;
  derived.func(); // this is derived func

 Base base;
 base.func(); // this is base func
}

Or if you use a pointer to the Base class, Base class’ function will be invoked

class Base {
  public:
    void func() {
      std::cout << "this is base func" << std::endl;
    }
};

class Derived : public Base {
  public:
    void func() {
      std::cout << "this is derived func" << std::endl;
    }
};

int main() {
  Derived derived;
  Base *basePtr = &derived;
 basePtr->func(); // this is base func
}

Or you can use :: operator to access Base class through Derived class

class Base {
  public:
    void func() {
      std::cout << "this is base func" << std::endl;
    }
};

class Derived : public Base {
  public:
    void func() {
      std::cout << "this is derived func" << std::endl;
    }
};

int main() {
  Derived derived;
  derived.func(); // this is derived func
 derived.Base::func(); // this is base func
}

b2. Virtual Methods: A virtual function is a member function that is declared in the base class using the keyword virtual and is re-defined (Overridden) in the derived class

class Base {
  public:
    virtual void fun() {
      std::cout << "base fun() called" << std::endl;
    }
};

class Derived : Base {
  public:
    void fun() override {
      std::cout << "overridden fun() called" << std::endl;
    }
};

int main() {
  Base base;
  base.fun(); // base fun() called

  Derived derived;
  derived.fun(); // overridden fun() called
}

there are more to virtual keyword, perhaps its best utility is that it allows the right function to be invoked when a function is called through an object with contradicting classes. let’s see how

#include <iostream>

// imagine we have such a base class
class Base
{
public:
 virtual void announce()
 {
  std::cout << "hello from base" << std::endl;
 }
};

// and such a derived class publicly inheriting
class Derived : public Base
{
public:
 void announce()
 {
  std::cout << "hello from derived" << std::endl;
 }
};

int main()
{
 // Base base;
 // base.announce(); // hello from base

 // Derived derived;
 // derived.announce(); // hello from derived

 // it is okay so far for we kept it simple
 // but what if one would want to say

 /*  we create an object with Base pointer but from Derived()
  class. it must say "hello from derived" since it is instantiated
  from Derived class. and actually it does, only thanks to the "virtual"
  keyword and the equality of names in the both classes. if we were to
  remove the virtual keyword from the function in the base class,
  obj->announce() would print <hello from base> because OS wouldn't know
  it is supposed to implicitly override the function according to the derived
  class. Or, another scenario - if we kept the virtual but assigned different
  names for the functions, it'd still use Base's function. */
 Base *obj = new Derived();
 obj->announce(); 
}

2) ABSTRACTION

There are two types of abstraction:

1. data abstraction: it involves hiding the complex details of data and representing only the essential features. For instance user just creates objects from a certain class. S/he doesn’t need to know about the data types these properties are stored in, architecture and/or structure used in the class etc.

class Car {
 private:
     std::string brand;
     int year;
 
 public:
     Car(std::string b, int y) : brand(b), year(y) {}
 
     void displayInfo() {
         std::cout << "Brand: " << brand << ", Year: " << year << std::endl;
     }
};

2. process abstraction: it is where we shortcut certain executions using functions/methods. User only needs to know what a function does and not its content.

int addNumbers(int a, int b) {
    return a + b;
}

int main() {
    int result = addNumbers(5, 7);
    
    std::cout << "Result: " << result << std::endl;

    return 0;
}

3) INHERITANCE

Inheritance is another pillar of OOP which means a class can inherit from another class. Therefore, it copies its attributes and methods but it can also add some extra features in future.

1. public inheritance: it inherits all the public and protected members as public and protected respectively. however, private members are NOT inherited to the derived class.

class Animal {
public:
  void eat() { std::cout << "Animal is eating." << std::endl; }
};

class Dog : public Animal {
public:
  void bark() { std::cout << "Woof!" << std::endl; }
};

// Usage:
Dog dog;
dog.eat();  // Inherited from Animal
dog.bark(); // Dog's own method

2. private inheritance: the public and protected members of the base class are inherited as private members of the derived class.

class Animal {
public:
  void eat() { std::cout << "Animal is eating." << std::endl; }

protected:
  void sleep() { std::cout << "Animal is sleeping." << std::endl; }
};

class Snake : private Animal {
public:
  void hiss() {
    std::cout << "SSSnake sound..." << std::endl;
    sleep();  // Inherited from Animal, but not accessible outside
  }
};

int main() {
  Snake snake;
  snake.hiss();  // OK
  // snake.eat();  // Error: eat() is private in Snake
}

3. protected inheritance: the public and protected members of the base class are inherited as protected members of the derived class. The private members are NOT accessible by the derived class.

class Shape {
protected:
  double width, height;
public:
  void setDimensions(double w, double h) { width = w; height = h; }
};

class Rectangle : protected Shape {
public:
  double getArea() const { return width * height; }
};

4) ENCAPSULATION

This is where the two main cores of a class (attributes & methods) are bundled together and start acting like a single unit. Then, encapsulation permits us to control their accessibility & modifiability.

1. data hiding is where the attributes/data members of a class are made private, so they are not accessible from the outer scopes. This enables safer and integrated codes.

class Person {
 private:
     int age;
 
 public:
     // ... public methods that interact with name and age
};

2. the total opposite, encapsulation also offers an interface that allows the user to interact & modify content. these are conventionall called getter() & setter() functions

class Person {
private:
    int age;

public:

    // getter() function for the data member
    int getAge() const {
        return age;
    }

    // setter() function for the data member
    void setAge(int newAge) {
        if (newAge >= 0) {
            age = newAge;
        }
    }
};

Encapsulation allows for three different levels of protection:

1. public: variables defined under the public tag can be used in different scopes

class User {
 public:
  int age;
};

int main() {
 User u1;
 u1.age = 30;
 std::cout << u1.age << std::endl; // 30
}

2. private: variables defined under private tag can only be called/modified through getter/setter functions

class User {
 private:
  int age;

 public:
  int getAge() {
   return age;
  }
  void setAge(int _age) {
   age = _age;
  }

};

int main() {
 User u1;
 u1.setAge(30);
 std::cout << u1.getAge() << std::endl; // 30
}

3. protected: variables defined under protected tag can be accessed both by getter/setters and inheriting classes

class BaseUser {
protected:
    int protectedAge;

public:
    void setProtectedAge(int _age) {
        protectedAge = _age;
    }

    int getProtectedAge() const {
        return protectedAge;
    }
};

class DerivedUser : public BaseUser {
public:
    void modifyProtectedAge() {
        protectedAge = 25; // we access it in the inheriting class
    }
};

int main() {
    DerivedUser u1;

  // because it is not public, we can't say
  // u1.protectedAge = 40;

  // but we can modify it through setters()
    u1.setProtectedAge(30);
  // reach it through getters()
    std::cout << u1.getProtectedAge() << std::endl;  // 30
    // or access through inheriting class' object
  u1.modifyProtectedAge();
    std::cout << u1.getProtectedAge() << std::endl;  // 25

    return 0;
}

So that was OOP in a nutshell. There might be slight errors and/or lacks— yet, thanks for reading!