01:44 <FromGitter> <jwaldrip> is it possible to get the type of a var passed to a macro?

01:52 <FromGitter> <jwaldrip> doesnt look like it :-(

01:52 <FromGitter> <jwaldrip> even though the compiler should know the type

01:53 <FromGitter> <jwaldrip> just looking to see if I can convert a named tuple to inline vars.

01:56 <postmodern> where do you / how do you compile benchmark scripts for shards? Coming from ruby, I'd inject lib/ into $LOAD_PATH, but with crystal i assume i'd want to compile src/ along with the benchmark script?

02:28 <FromGitter> <Daniel-Worrall> `sleep 0.seconds`

02:34 <FromGitter> <mixflame> thx

02:52 <postmodern> nm, remembered that i could use macros to generate a bunch of explicit requires to pull in stuff from ./src/

03:07 <FromGitter> <jwaldrip> can you get the protocol from an http request?

03:24 <woodruffw> @jwaldrip: both HTTP::Request and HTTP::Response have a `#version` getter

03:25 <woodruffw> (assuming that's what you mean by the protocol)

03:28 <postmodern> why are crystal binaries not compiled with --release significantly slower than --release compiled binaries?

03:35 <FromGitter> <naqvis> should be due to compiler optimization

03:37 <postmodern> ah, wondering if there are extra checks for debugging in non-release builds or something

03:39 <FromGitter> <naqvis> I would say that debug info just bloat the size, but shouldn't have any impact on the speed. Its just LLVM optimizations aren't set during the normal build

03:40 <FromGitter> <naqvis> for sure, some one from core team need to provide the exact details :P

03:43 <FromGitter> <naqvis> or you can do a quick spike to see if binaries built in release mode with and without full symbolic debug info shows any differences ⏎ ` `` ⏎ crystal build --no-debug --release xxxxxxx ⏎ crystal build -d --release xxxxxx ⏎ ... [https://gitter.im/crystal-lang/crystal?at=5f0d29f746c75b1e5e442350]

03:53 <FromGitter> <wontruefree> I just released another great episode on a different way to design a web framework in Crystal. http://podcast.chicagocrystal.org/1030945/4559792-george-dietrich-athena-reborn

03:56 <postmodern> i don't suppose there's an easy way to embed a C library into a crystal shard? trying to optimize digest-crc.cr

04:01 <FromGitter> <wontruefree> there is a few different directions you could take there is a good explanation here https://crystal-lang.org/reference/syntax_and_semantics/c_bindings/

04:02 <FromGitter> <wontruefree> also this can work for most libs and is good when it works for me https://github.com/crystal-lang/crystal_lib

04:03 <FromGitter> <wontruefree> Sushi Chain also has a lot of c extensions and I find is a good example for using C extensions in their libs https://github.com/SushiChain/

04:06 <postmodern> wontruefree, when I say embed, I mean putting the C code directly into the shard repo, instead of binding to a pre-installed C library.

04:06 <postmodern> I'm guessing LD_LIBRARY_PATH would give me problems?

04:35 <FromGitter> <mixflame> Can you guys identify anything about my server that I'm doing asynchonously that I'm doing wrong?

04:35 <FromGitter> <mixflame> https://github.com/mixflame/GlobalChat2/blob/master/crystal-gchat-server/src/crystal-gchat-server.cr

04:36 <FromGitter> <mixflame> When I send large data (large amount of POINTs) the client can't receive chats at the same time.

04:37 <FromGitter> <mixflame> Or am I just simply pushing the client socket to it's limit?

04:37 <FromGitter> <mixflame> I haven't found a good place to `sleep` or `sleep 0.seconds` yet

04:38 <woodruffw> postmodern: building a static library and linking to it _should_ work -- i think i did that a year or so ago

04:40 <woodruffw> assuming that you're linking to things the usual way, passing `--static` to either `shards` or `crystal` should do the trick

04:53 <FromGitter> <naqvis> postmodern you can link the `.o` file when building your crystal app

05:31 <postmodern> woodruffw, naqvis, good to know. i'll look into static linking

05:32 <postmodern> hmm but how does one do that via a shard that isn't meant to be executable, but be compiled into other projects?

05:32 <postmodern> has to be some way of propegating linking flags from the shard

05:46 <FromGitter> <wontruefree> if people are interesting in hearing more about Athena we also are now able to upload to youtube https://youtu.be/VVuLZvpCUAs

05:53 <FromGitter> <naqvis> postmodern link flags will be placed in your shard via `@[Link...]` annotation and compiler will take care of that

05:54 <FromGitter> <naqvis> but if your shard need to compile some C code, then you can use `postinstall` hook of Shards, provide Makefile and invoke that during `postinstall` hook

05:56 <FromGitter> <naqvis> for example ⏎ ⏎ https://github.com/naqvis/webview/blob/master/src/lib.cr#L2-L13 ⏎ https://github.com/naqvis/webview/blob/master/shard.yml#L11 ⏎ https://github.com/naqvis/webview/blob/master/Makefile [https://gitter.im/crystal-lang/crystal?at=5f0d48f386ccb45b59a5c683]

06:36 <postmodern> naqvis, excellent information, thank you

06:39 <FromGitter> <naqvis> you are welcome 👍

11:59 <FromGitter> <jaitaiwan_gitlab> Evening everyone! Would someone have a learning resource suggestion for learning about how to take an integer (such as the unix file mode flags) and split it out into "sections" like Crystal has done with File::Permissions, File::Type and File::Info?

11:59 <FromGitter> <jaitaiwan_gitlab> I assume it's something to do with bit-shifting, I'm just not certain.

12:12 <yxhuvud> jaitaiwan: See https://crystal-lang.org/reference/syntax_and_semantics/enum.html#flags-enums

12:13 <yxhuvud> Or am I misunderstanding the question?

12:15 <FromGitter> <jaitaiwan_gitlab> Thanks for that yxhuvud. I have already looked at that... the issue is that I need to convert from a unix integer to the Enum's I mentioned above (File::Type, File::Permissions, File::Info)

12:28 <FromGitter> <naqvis> @jaitaiwan_gitlab you would need to bitwise `and` and `or` to achieve the outcome. You can refer to my implementation of `File::Info` in Crystar (https://github.com/naqvis/crystar) for references purposes ⏎ https://github.com/naqvis/crystar/blob/master/src/tar/header.cr#L423-L499

12:40 <FromGitter> <Blacksmoke16> @jwaldrip if you pass it like `var : Int32` yes

14:01 <FromGitter> <andrewc910> Best way to encrypt/decrypt a serialized object? Can't find anything in the api docs :/

14:16 <FromGitter> <naqvis> This will depend on how "Best" is defined, also which stdlib api did you try?

14:20 <FromGitter> <jwaldrip> @Blacksmoke16 will that give me whether its http/https?

14:21 <FromGitter> <Blacksmoke16> got an example of what you're trying to do?

14:23 <FromGitter> <andrewc910> @naqvis best as in most conventional? I was looking into Openssl::Cipher as it was the only `encrypt` method. Couldn't really figure it out.

14:29 <FromGitter> <andrewc910> `Digest::SHA1.base64digest("foo")` I believe i might of found it

14:32 <FromGitter> <naqvis> @andrewc910 compression related modules are located under `Compress` namespace

14:32 <FromGitter> <naqvis> stdlib comes with `Zip`, `Gzip`, `ZLib`, `Deflate`

14:33 <FromGitter> <naqvis> but if you need other compression formats then you will need to use external shards

14:34 <FromGitter> <naqvis> my github account has few like `Brotli`, `XZ`, `LZ4`, `Snappy` etc

14:34 <FromGitter> <naqvis> similarly you can find others via different shards

14:37 <FromGitter> <andrewc910> @Blacksmoke16 ⏎ ⏎ ```code paste, see link``` [https://gitter.im/crystal-lang/crystal?at=5f0dc31e49fe212794946ee7]

14:37 <FromGitter> <Blacksmoke16> what about it?

14:38 <FromGitter> <andrewc910> `got an example of what you're trying to do?` oh, maybe this wasn't aimed at me! If not, my apologies for pinging ya

14:38 <FromGitter> <Blacksmoke16> yea sorry, that was to @jwaldrip

14:38 <FromGitter> <andrewc910> NP

14:40 <FromGitter> <naqvis> @andrewc910 Sorry I thought your question was regarding compression :P

14:40 <FromGitter> <naqvis> but seems you are after Encryption

14:41 <FromGitter> <Blacksmoke16> that is what he said :P

14:41 <FromGitter> <Blacksmoke16> 🙈

14:41 <FromGitter> <naqvis> lol

14:41 <FromGitter> <naqvis> apologies

14:41 <FromGitter> <naqvis> please take a look at `Crypto` module in stdlib

14:42 <FromGitter> <naqvis> also `OpenSSL` provides some Algos like SHAXX

14:44 <FromGitter> <andrewc910> Is crypto::base64 what I am looking for? encode/decode?

14:45 <FromGitter> <Blacksmoke16> theres a diff between encoding and encrypting

14:46 <FromGitter> <Blacksmoke16> to be clear you want encrypting yes?

14:46 <FromGitter> <Blacksmoke16> i guess the question to ask whats the goal with this? To prevent people from seeing the content, or making sure no one tampered with the content?

14:50 <FromGitter> <andrewc910> Hmm, i believe encrypt. I am doing something like this: https://github.com/unabridged/motion ⏎ ⏎ TLDR: Serialize objects, store in html doc. User clicks on event, JS sends serialized object to server, server recreates object, invokes the event, sends new state back for rendering. ⏎ ⏎ Because i have to store the state of the object in an HTML doc and the user has access to this, i believe

14:50 <FromGitter> ... preventing tampering would be best. [https://gitter.im/crystal-lang/crystal?at=5f0dc624f253d22569d52c05]

14:50 <FromGitter> <Blacksmoke16> sounds like a lot of work

14:52 <FromGitter> <andrewc910> It's a lot more work when you can't even figure out how encrypt a dang json!

14:52 <FromGitter> <Blacksmoke16> this is something that could deff be improved on, is kinda a pita ;P

14:53 <FromGitter> <jwaldrip> @Blacksmoke16 I am trying to provide a url helper for views and I want to be able to link to a particular asset and know whether or not the incoming request is over http or https

14:57 <FromGitter> <naqvis> if its plain Ajax/WS like communication, then JSON is already the format. But if remote server is expecting the contents to be encrypted using some specific encryption algorithm, then you can encrypt them and send the encrypted data via base64 encoding (if other side is expecting text) or you can simply send the encrypted binary

14:57 <FromGitter> <naqvis> encryption methods, turns data into binary format

14:58 <FromGitter> <naqvis> for example, if you want to encrypt the data using SHA512 algorithm and send encrypted data as base64 then try sth like below ⏎ ⏎ ```code paste, see link``` [https://gitter.im/crystal-lang/crystal?at=5f0dc80c9c75aa256b3d4600]

14:59 <FromGitter> <naqvis> but plz. bear in mind encryption/decryption is cpu-intensive activity

15:06 <FromGitter> <Blacksmoke16> what would be the data tho

15:08 <FromGitter> <Blacksmoke16> i.e. dont you need the data to encrypt + a key used to encrypt it?

15:12 <FromGitter> <andrewc910> The actual data is serialized component. A component is just like a react component. Here is an example with ruby: https://github.com/unabridged/motion-demos/blob/master/app/components/calculator_component.rb ⏎ ⏎ The object is serialized and store in the view so the state can pick up where it left off. ⏎ ⏎ If i leave is as a plain json, that opens up the door to users tampering with the data. If

15:12 <FromGitter> ... base64 encoding solves this problem, that's fine with me. I have only worked with hashes before. ... [https://gitter.im/crystal-lang/crystal?at=5f0dcb6854d58c013a40b911]

15:12 <FromGitter> <andrewc910> I found this which looks promising! https://www.reddit.com/r/crystal_programming/comments/ak39oh/how_to_use_opensslcipher_to_encrypt_data_with_aes/

15:13 <FromGitter> <andrewc910> Yes the key would be stored on the server. Right now it just just hardcoded to a file.

15:17 <FromGitter> <naqvis> if data isn't that sensitive, i would say you can calculate the signature and store that along with json contents, on receiving side, you can validate the contents by calculating the signature and comparing that with the provided one. This will save you effort of encrypting/decrypting whole data on both sides

15:21 <FromGitter> <andrewc910> Hmm, can you point me at the api docs or an article? I don't understand `calculate the signature`

15:22 <raz> andrewc910: do you control both the encrypting and decrypting side?

15:22 <FromGitter> <naqvis> by signature i mean hash of JSON contents, it could be either MD5 or any SHAXX

15:22 <FromGitter> <andrewc910> Yes

15:22 <raz> andrewc910: and https (encrypted transport) is not enough?

15:23 <FromGitter> <andrewc910> @naqvis so hash the json. Then when i get the request, rehash the json and make sure they are the same?

15:23 <FromGitter> <naqvis> yeah

15:23 <raz> andrewc910: ah, it looks like what you want is a JWT

15:24 <FromGitter> <andrewc910> The json is the state of the view being store in the html doc. I am not worried about the state being manipulated in transit. I am worried users will manually manipulate the state in the inspector tool, fire off a request & now a manipulated object is running on the sever.

15:25 <FromGitter> <andrewc910> I am no security expert. I have no idea what could happen with a user manipulating the state of a view object but i don't really want to find out.

15:25 <FromGitter> <naqvis> if json contents are modified, their hash will be different

15:25 <raz> https://jwt.io/ - or if you don't need to be compatible to a standard, an easier version with modern crypto: https://github.com/busyloop/suzuri

15:25 <FromGitter> <andrewc910> @ali, i will give it a go! Thanks :)

15:25 <FromGitter> <naqvis> 👍

15:28 <raz> (would advise against trying custom stuff with signatures unless you know what you're doing - the standard thingers exist because it's easy to get it subtly wrong)

16:13 <FromGitter> <tenebrousedge> o/

21:47 <FromGitter> <nolyoi> def initialize(index = 0, data = "data", previous_hash = "hash") ⏎ ⏎ ```code paste, see link``` ⏎ ⏎ Error: instance variable '@index' of CrystalChain::Block must be Int32, not String [https://gitter.im/crystal-lang/crystal?at=5f0e27ee26b22649721e95e7]

21:47 <FromGitter> <nolyoi> any clues why I'm getting this error that @index is being interpreted as a string?

21:48 <FromGitter> <Blacksmoke16> can you share more of the code/error?

21:48 <FromGitter> <nolyoi> require "openssl" ⏎ ⏎ module CrystalChain ⏎ class Block ⏎ ... [https://gitter.im/crystal-lang/crystal?at=5f0e2828ff29b777320133a6]

21:48 <FromGitter> <nolyoi> ```code paste, see link``` [https://gitter.im/crystal-lang/crystal?at=5f0e284a343f5d69494dcbdc]

21:49 <FromGitter> <Blacksmoke16> well you're passing `"Hello, Crypto!"` as the `index` argument

21:49 <FromGitter> <Blacksmoke16> `index = 0` doesnt restrict the type, just sets a default value

21:50 <FromGitter> <Blacksmoke16> so id imagine somewhere else you are doing `@index : Int32`, when its essentially doing `@index = "Hello, Crypto!"`, hence the error

21:55 <FromGitter> <nolyoi> hmm, type was never set anywhere. so technically it shouldve still ran right? thats the entire code there. I get what youre saying though. I forgot to add the data: in `CrystalChain::Block.new("Hello, Crypto!").hash`

21:56 <FromGitter> <Blacksmoke16> actually `index = 0` prop infers the type

21:58 <FromGitter> <Blacksmoke16> yea https://crystal-lang.org/reference/syntax_and_semantics/type_inference.html#5-assigning-a-variable-that-is-a-method-argument-with-a-default-value

22:31 <FromGitter> <nolyoi> I'm following a tutorial to try and help learn things a bit. Running into another problem. ⏎ ⏎ ```code paste, see link``` ⏎ ⏎ Why am I having to call variables like this: previous_node.@index? if I dont, im getting the undefined method error. seems very odd. [https://gitter.im/crystal-lang/crystal?at=5f0e323b1cc043695962d8ea]

22:31 <FromGitter> <Blacksmoke16> as the error says, there isnt a method called `.index`

22:32 <FromGitter> <Blacksmoke16> just defining an ivar doesnt expose it

22:32 <FromGitter> <Blacksmoke16> and you shouldnt do `.@index` thats a low level hack

22:32 <FromGitter> <Blacksmoke16> add getters for the ivars you want to expose

22:32 <FromGitter> <Blacksmoke16> https://crystal-lang.org/api/master/Object.html#getter(*names,&block)-macro

22:32 <FromGitter> <nolyoi> ok, cause in the references it uses this as an example ⏎ ⏎ ```code paste, see link``` [https://gitter.im/crystal-lang/crystal?at=5f0e3297d6039801464ed92b]

22:33 <FromGitter> <Blacksmoke16> right `property` macro defines a getter/setter

22:33 <FromGitter> <Blacksmoke16> `getter` defines a getter but not a setter

22:33 <FromGitter> <nolyoi> ahhh!

22:52 <FromGitter> <Blacksmoke16> mhm