Thread overview
Pazar Sohbeti: 15 Mayıs'22, TSİ.11
May 15
Rohat
May 10

Bu Pazar, Türkiye saati ile 11'de...
15/05/22-TSİ.11

Ali Çehreli eşliğinde, herkesi görüntülü sohbete bekliyoruz:

TIKLA ve BAŞLA -> https://meet.jit.si (bu kadar...)

Şimdilik 2 konumuz var:

  • D Dili Neden Popüler Değil, şu başlık alev alev yanıyor:
    https://forum.dlang.org/thread/axslxubumvtrudpjfpng@forum.dlang.org

  • Kod Yazarken Verimlilik, yan konular:
    _ Erişilebilir Olma
    _ Etkin Kod Yazma
    _ İşbirliği, ekip katılımlı projeler
    _ Hata töleransı, unit testler
    _ Öğrenmesi kolay olmayanı dışlama
    _ Karmaşık tasarım ve kafa karıştırıcı öğeleri temizleme

Başka konu/konuk varsa lütfen C.tesi gününe kadar belirtiniz.

May 10

On Tuesday, 10 May 2022 at 10:41:47 UTC, Salih Dincer wrote:

>

TIKLA ve BAŞLA -> https://meet.jit.si (bu kadar...)

Adres şöyle olacaktı: https://meet.jit.si/Ddili

Özür...

May 10

On Tuesday, 10 May 2022 at 10:43:39 UTC, Salih Dincer wrote:

>

On Tuesday, 10 May 2022 at 10:41:47 UTC, Salih Dincer wrote:

>

TIKLA ve BAŞLA -> https://meet.jit.si (bu kadar...)

Adres şöyle olacaktı: https://meet.jit.si/Ddili

Özür...

Benim toplantıda tartışılabilecek ufak bir sorum var.

Walter Bright tarafından şöyle bir cevap gördüm: "Right, D doesn't have async/await. That's mainly because nobody has spent the time to figure out how to do it, not because I'm blocking it."

Ben oyun geliştirirken(C#) async/await'i tek thread üzerinde işlem yapmak için fazlasıyla kullanıyorum. Belki D tarafında kesin daha uygunu vardır.(Olduğuna inanıyorum :)) Bu D için bir eksik mi? Sizlerin bu konudaki görüşlerinizi merak ediyorum.

May 13

On Tuesday, 10 May 2022 at 12:47:45 UTC, Huseyin Sencan wrote:

>

On Tuesday, 10 May 2022 at 10:43:39 UTC, Salih Dincer wrote:

>

On Tuesday, 10 May 2022 at 10:41:47 UTC, Salih Dincer wrote:

>

TIKLA ve BAŞLA -> https://meet.jit.si (bu kadar...)

Adres şöyle olacaktı: https://meet.jit.si/Ddili

Özür...

Benim toplantıda tartışılabilecek ufak bir sorum var.

Walter Bright tarafından şöyle bir cevap gördüm: "Right, D doesn't have async/await. That's mainly because nobody has spent the time to figure out how to do it, not because I'm blocking it."

Ben oyun geliştirirken(C#) async/await'i tek thread üzerinde işlem yapmak için fazlasıyla kullanıyorum. Belki D tarafında kesin daha uygunu vardır.(Olduğuna inanıyorum :)) Bu D için bir eksik mi? Sizlerin bu konudaki görüşlerinizi merak ediyorum.

Evet, tam olarak neden bahsediyor? Çünkü şöyle şeyler de var:

import core.thread;
import core.sync.mutex;
import core.sync.semaphore;
import core.sync.condition;
void main()
{
    auto mutex      = new Mutex;
	auto condReady  = new Condition( mutex );
	bool waiting    = false;
	bool alertedOne = true;
	bool alertedTwo = true;

	void waiter()
	{
		synchronized( mutex )
		{
			waiting    = true;
			// we never want to miss the notification (30s)
			alertedOne = condReady.wait( dur!"seconds"(30) );
			// but we don't want to wait long for the timeout (10ms)
			alertedTwo = condReady.wait( dur!"msecs"(10) );
		}
	}

	auto thread = new Thread( &waiter );
	thread.start();

	while ( true )
	{
		synchronized( mutex )
		{
			if ( waiting )
			{
				condReady.notify();
				break;
			}
		}
		Thread.yield();
	}
	thread.join();
	assert( waiting );
	assert( alertedOne );
	assert( !alertedTwo );
}

Aslında D'de çok şey var, biraz kafa karıştırıcı ama var oğlu var! Biraz C'den devraldıkları, biraz C++'a rakip şeyler ve genel geçer kaideler. Sen ne aşamadasın Hüseyin, toplantıda üzerinden geçmemizi istediğin basit konulardan ne var? Mesela struct'ları kullanabiliyor musun? Onlar ne kadar da güzel şeyler değil mi?

Bu arada std.sumtype'a artık bir girsek mi? En son giremedik sanırım :)

Sevgiler, saygılar...

May 13

Walter şöyle de yazmış:

On Friday, 29 April 2022 at 15:36:34 UTC, Walter Bright wrote:

>

I don't know what the rewrites of async/await would be. If someone would write that down, I doubt it would be that hard. After all, I got ImportC to work :-/

Eee, kimse girişmediyse hadi yapalım şunu? Ali hocam destekler mi? Şurada olayı anlatmış ve gayet basit:

https://javascript.info/async-await

Başarılar...

May 13

On Friday, 13 May 2022 at 07:24:03 UTC, Salih Dincer wrote:

>

Aslında D'de çok şey var, biraz kafa karıştırıcı ama var oğlu var! Biraz C'den devraldıkları, biraz C++'a rakip şeyler ve genel geçer kaideler. Sen ne aşamadasın Hüseyin, toplantıda üzerinden geçmemizi istediğin basit konulardan ne var? Mesela struct'ları kullanabiliyor musun? Onlar ne kadar da güzel şeyler değil mi?

Kesinlikle katılıyorum Salih Hocam. struct'ları sıklıkla kullanıyorum. Ali Hocam dersime konuk olduğu zamanda da bahsetmişti. C#'da D gibi struct yapılarına sahip. Gerçekten kullanmasını bilince hem ram konusunda hem de optimizasyon konusunda çok işime yarıyor.

Benim bildiklerime ve sorularıma gelirsem; benim genel yazılım ve D konusunda sizler kadar bilgim olmadığından sizin sorularınız üzerine konuları dinleyip. Oradan bir şeyler öğrenmeyi çok seviyorum. Sorularım olduğunda da konu üzerinde anlatım yapılırken direkt soru soruyorum. Şu aralar D'ye daha da fazla zaman ayırmaya karar verdim. O zaman sık sık sorum olacaktır :)

May 14

On Friday, 13 May 2022 at 11:58:03 UTC, Huseyin Sencan wrote:

>

[...] öğrenmeyi çok seviyorum. Sorularım olduğunda da konu üzerinde anlatım yapılırken direkt soru soruyorum. Şu aralar D'ye daha da fazla zaman ayırmaya karar verdim. O zaman sık sık sorum olacaktır :)

Neler öğrendin? Kendi kütüphaneni oluşturmaya başladın mı? Şöyle küçükten başlayıp, unittest'lerini de yap at köşeye...

Örneğin çok zevkli olan Fibonacci serisi ile denemeler yaptın mı? Kesin biliyorsundur da kaynağı şurada:

https://en.m.wikipedia.org/wiki/Fibonacci_number

Hatta dur! Buraya kütüphanemden çerez ilginç bir şey yapıştırayım. Bu özyineleme ve switch case'i kullanımına örnektir. Basittir, öğreticidir:

void fiboNYaz(long N, long a = 0, long b = 1) {
  switch(N) {
    case 0: writeln("0"); return;
    case 1: writeln("1"); return;
    case 2: writeln(a+b); return;
    default: fiboNYaz(N-1,b,a+b);
  }
} // enum limit = 92;

Bunun daha basitleri, tek satırlık olanları (recurrence!((a,n) => a[n-1] + a[n-2])(0, 1)) ve Ali hocanın aralıkları anlatırken verdiği yapı (struct) vardır:

http://ddili.org/ders/d/araliklar.html
(Sonsuz Aralıklar Başlığı)

Senden bir ricam var. Lütfen Aralıklar(Range) konusunu sil süpür. Bu çok güzel bir olanak. Yarın için sorularını bekliyor olacağız.

Sevgiler, saygılar...

May 15

On Tuesday, 10 May 2022 at 10:41:47 UTC, Salih Dincer wrote:

>

Bu Pazar, Türkiye saati ile 11'de...
15/05/22-TSİ.11

Ali Çehreli eşliğinde, herkesi görüntülü sohbete bekliyoruz:

TIKLA ve BAŞLA -> https://meet.jit.si (bu kadar...)

Şimdilik 2 konumuz var:

  • D Dili Neden Popüler Değil, şu başlık alev alev yanıyor:
    https://forum.dlang.org/thread/axslxubumvtrudpjfpng@forum.dlang.org

  • Kod Yazarken Verimlilik, yan konular:
    _ Erişilebilir Olma
    _ Etkin Kod Yazma
    _ İşbirliği, ekip katılımlı projeler
    _ Hata töleransı, unit testler
    _ Öğrenmesi kolay olmayanı dışlama
    _ Karmaşık tasarım ve kafa karıştırıcı öğeleri temizleme

Başka konu/konuk varsa lütfen C.tesi gününe kadar belirtiniz.

Merhabalar

Ben bugün katılamayacağım nişanlımı sınava götüreceğim. Size iyi eğlenceler :)

May 15
Bu sefer aşağıdakileri karaladık.

Ali

/*

  DDili sohbet - 15 Mayıs 2022

  - SumTypes

  - ImportC (artık D derleyicisi preprocessorlık da yapıyor)

  - ImportC sayesinde bitfields D'ye de geldi (betterC'ye geldi)

  - DConf
  Ali'nin fikirleri:
  -- ImportC kullanım örnekleri

  -- Back to Basics (lvalue vs. rvalue VEYA kullanım kolaylıkları (lowerings --> for döngüsü yerine foreach yerine aralıklar))

  -- Andrei'nin önerisi: Phobos'ta perde arkası + Ali'nin .cached algoritması

  - Popüler değil

  - async/await

  Future!int yarinHava = async_foo("havadurumu.com");
//   Promise!int yarinHava = async_foo("havadurumu.com");
  // ...
  // ...
  // ...
  try/catch -> Masraflı
  mutex -> Masraflı
  synchronized -> Masraflı
  vs.

  writeln(yarinHava.await);  // Ya hazır ya da bekleyecek

*/

/+
import std;

union U {
  int i;
  string s;
  double d;
}

struct ___SSSSS {
  size_t length;
  char* ptr;
}


void main() {
  auto u = U(42);
  u.d = 1.5;
  writeln(u.s.length);
}
+/





/+
import std.variant;
import std.stdio;


void main() {
  Variant a; // Must assign before use, otherwise exception ensues
  // Initialize with an integer; make the type int
  Variant b = 42;
  writeln(b.type); // typeid (int)
  // Peek at the value
  assert(b.peek!(int) !is null && *b.peek!(int) == 42);
  // Automatically convert per language rules
  auto x = b.get!(real);

  // Assign any other type, including other variants
  a = b;
  a = 3.14;
  writeln(a.type); // typeid (double)
  // Implicit conversions work just as with built-in types
  assert(a < b);
  // Check for convertibility
  assert(!a.convertsTo!(int)); // double not convertible to int
  // Strings and all other arrays are supported
  a = "now I'm a string";
  writeln(a); // "now I'm a string"

  auto l = (int i) => i * 2;
  a = l;
  writeln((*a.peek!(typeof(l)))(42));
}
+/





/+
import std.variant;

struct S {
  int i;
  string isim;
}

void main() {
  auto v = Algebraic!(int, double, string, S)(5);
  assert(v.peek!(int));
  v = 3.14;
  assert(v.peek!(double));

  import std.stdio;
  writeln(v);
  // auto x = v.peek!(long); // won't compile, type long not allowed
  // v = '1'; // won't compile, type char not allowed

  v = S(42, "ali");
  writeln(v);
}
+/












/+ SumType is a generic discriminated union implementation
that uses design-by-introspection to generate safe and
efficient code. Its features include:

    Pattern matching.
    Support for self-referential types.
    Full attribute correctness (pure, @safe, @nogc, and nothrow are inferred whenever possible).
    A type-safe and memory-safe API compatible with DIP 1000 (scope).
    No dependency on runtime type information (TypeInfo).
    Compatibility with BetterC.
+/

/+
import std.math.operations : isClose;

import std.sumtype;

void main() {
  struct Fahrenheit { double degrees; }
  struct Celsius { double degrees; }
  struct Kelvin { double degrees; }

  alias Temperature = SumType!(Fahrenheit, Celsius, Kelvin);

  // Construct from any of the member types.
  Temperature t1 = Fahrenheit(98.6);
  Temperature t2 = Celsius(100);
  Temperature t3 = Kelvin(273);

  // Use pattern matching to access the value.
  Fahrenheit toFahrenheit(Temperature t)
  {
    return Fahrenheit(
      t.match!(
        (Fahrenheit f) => f.degrees,
        (Celsius c) => c.degrees * 9.0/5 + 32,
        (Kelvin k) => k.degrees * 9.0/5 - 459.4
               )
                      );
  }

  const hassasiyet = 0.5;

  assert(toFahrenheit(t1).degrees.isClose(98.6, hassasiyet));
  assert(toFahrenheit(t2).degrees.isClose(212));
  assert(toFahrenheit(t3).degrees.isClose(32));

  // Use ref to modify the value in place.
  void freeze(ref Temperature t)
  {
    t.match!(
      (ref Fahrenheit f) => f.degrees = 32,
      (ref Celsius c) => c.degrees = 0,
      (ref Kelvin k) => k.degrees = 273
             );
  }

  freeze(t1);
  assert(toFahrenheit(t1).degrees.isClose(32));

  // Use a catch-all handler to give a default result.
  bool isFahrenheit(Temperature t)
  {
    return t.match!(
      (Fahrenheit f) => true,
      _ => false
                    );
  }

  assert(isFahrenheit(t1));
  assert(!isFahrenheit(t2));
  assert(!isFahrenheit(t3));

  import std.stdio;
  writeln(t2);
  writeln(t3);
}
+/





/+

// https://dconf.org/2016/talks/clugston.html

/*

"to scale"

   +     +─────────+─────────+   ...   +   ...   +─────────+─────────+     +
   │   -max       -1         │         0         │         1        max    │
   │                         │                   │     │
-infinity               -min_normal          min_normal infinity

*/

import std.stdio;

void main() {
  long i = long.max - 1;
  writeln(i);

  double d = i;  // !!!!!!!!!!!!!!!!!!!
  // i = d;
  d *= 100;

  double d2 = d + 200000;
  writefln!"%f"(d);
  writefln!"%f"(d2);
  writeln(d2 - d);
  writeln(ulong(2) ^^ 18);

  writeln("merhaba\377dunya");
  // float
  //   double
  //   real
  //   char.init
  //   wchar
  //   dchar
}
+/








/+
import std.sumtype;
import std.stdio;
import std.functional : partial;
import std.traits : EnumMembers;
import std.typecons : Tuple;

void main() {
  enum Op : string
    {
      Plus  = "+",
      Minus = "-",
      Times = "*",
      Div   = "/"
    }

  /*
struct İşlem {
  Op op;
  İşlem* lhs;
  İşlem* rhs;
}
  */

  // An expression is either
  //  - a number,
  //  - a variable, or
  //  - a binary operation combining two sub-expressions.
  alias Expr = SumType!(
    double, // 0
    string, // 1
    Tuple!(Op, "op", This*, "lhs", This*, "rhs") // 2
                        );

  // Shorthand for Tuple!(Op, "op", Expr*, "lhs", Expr*, "rhs"),
  // the Tuple type above with Expr substituted for This.
  alias BinOp = Expr.Types[2];

  // Factory function for number expressions
  Expr* num(double value)
  {
    return new Expr(value);
  }

  // Factory function for variable expressions
  Expr* var(string name)
  {
    return new Expr(name);
  }

  // Factory function for binary operation expressions
  Expr* binOp(Op op, Expr* lhs, Expr* rhs)
  {
    return new Expr(BinOp(op, lhs, rhs));
  }

  // Convenience wrappers for creating BinOp expressions
  alias sum  = partial!(binOp, Op.Plus);
  alias diff = partial!(binOp, Op.Minus);
  alias prod = partial!(binOp, Op.Times);
  alias quot = partial!(binOp, Op.Div);

  /*
   // partial şurada: https://dlang.org/library/std/functional.html

   // Ali'nin farklı yazımı:

  Expr* sum(Expr* lhs, Expr* rhs) {
    return new binOp(Op.Plus, lhs, rhs);
  }
*/

  // Evaluate expr, looking up variables in env
  double eval(Expr expr, double[string] env)
  {
    return expr.match!(
      (double num) => num,
      (string var) => env[var],
      (BinOp bop)
      {
        double lhs = eval(*bop.lhs, env);
        double rhs = eval(*bop.rhs, env);
        final switch (bop.op)
        {
          // Thank you, Timon Gehr!
          static foreach (op; EnumMembers!Op)
          {
          case op:
            return mixin("lhs" ~ op ~ "rhs");
          }
        }
      }
    );
  }

  // Return a "pretty-printed" representation of expr
  string pprint(Expr expr)
  {
    import std.format : format;

    return expr.match!(
      (double num) => "%g".format(num),
      (string var) => var,
      (BinOp bop) => "(%s %s %s)".format(
        pprint(*bop.lhs),
        cast(string) bop.op,
        pprint(*bop.rhs)
       )
     );
  }

  Expr* myExpr = sum(var("a"), prod(num(2), var("b")));
  double[string] myEnv = ["a":3, "b":4, "c":7];

  writeln(eval(*myExpr, myEnv)); // 11
  writeln(pprint(*myExpr)); // "(a + (2 * b))"
}
+/





/+
import std;

void main() {
  auto a = tuple(42, "merhaba");

  static foreach (i, T; typeof(a).expand) {
    writefln!"%s %s"(typeof(T).stringof, a[i]);
  }
}
+/








import std;

void main() {
  // Design by Introspection
  // static if (isRandomAccessRange!R) {
  //   ...
  // }
  writeln(iota(0, 10_000_000, 42).map!(i => i * i).take(3)[2]);
}