futil | minimal utilities for Scala Futures | Functional Programming library

Every article up on the internet suggests me using RGB. But, I want to use Apple's green colour palette and I am futile in the venture. I know it's hashtag value but, unable to render it on the simulator due to the fact that I don't know the appropriate method to use it inside the view controller file.

Since, I have been able to render the desired colour by using Color Literal but, there is never an ending to learning. And, I want to know the coding way of it!

self.buttonStart.backgroundColor = UIColor(?)

? : What should I put inside the aforementioned parentheses to accomplish my task. Any suggestions?

I use dockerfiles to create a container. I know docker, but my bash understanding is very very limited. I know this question is probably a duplicate, but I don't understand what to search for.

Issue The step RUN export A_NUM=$(echo ${A_VERSION} | head -c 3) does not work. Even though in bash it perfectly works. I tried:

1. setting ENV A_VERSION=$A_VERSION
2. replicating my issue in bash (by going into the built container)

Any export statement in the dockerfile seems to be futile - can anybody explain this?

Setting

I have app_A and app_B. When I configure app_B I need to take the chosen version of app_A into account. A simplified dockerfile looks like this:

This issue has been gone over a thousand times but none of the answers successfully do this very simple thing in Typescript. I have an American Central/Chicago (UTC-5 or -6 depending on DST) time date string entering my service from an integrator that looks like this:

In a free Ruby course I'm working through, I was shown the way to create a default value for a hash via constructor. And it looks like so:

I am using the plot_model function from the library sjPlot for diagnostic plots of a linear regression. If you have a univariate regression, it outputs 3 plots, if you have a multivariate regression then there are 4 plots. The plots update dynamically with checkboxGroupInput but I get 'Error: subscript out of bounds' where the 4th plot should be when I only have 1 input checked. I want the spot for the 4th plot to just return blank if there is only 1 input checked.

I include a sample of 150 rows generated with dput: [redacted]

does anyone know how I could use a for loop to iterate through this?

I am trying to pass the date into a file e.g.:

/pwd # date > file.txt

but every time I check the file, nothing is printed in there. I have tried other variants as well e.g.:

/pwd # echo "$(date)" > file.txt

/pwd # echo "$(/bin/date)" > /full/path/file.txt

/pwd # echo "$(/bin/date)" >> /full/path/file.txt (I wouldn't expect appending to make a difference but tried anyway)

I thought well maybe it was some sort of permissions issue with date being able to access the file so, for kicks, I tried:

/pwd # sudo date > /full/path/file.txt

Attempting to store the date to bash variable is futile as well. But, sure enough, the date command by itself continues to work:

Mon Apr 5 14:16:26 UTC 2021

Anyone have any ideas what could be happening? According to every other post I've read, the things I am trying should be working.

Note this is a special (proprietary) kernel (uname -a):

However it's built on Debian so I would expect it to work.

EDIT: type date:

date is a tracked alias for /bin/date

Nothing interesting happens when prefixing command with set -x other than the tracking I see when running the command:

strace looks like it has some good information but I won't pretend to know how to interpret it:

EDIT 2:

Edit 2: Updated to take care of the problems from the dput output.

I don't know why the dput output is not working, so here is a roundabout way of sharing the data.

A simple zip file of the data can be downloaded from here: link to zip file

The following code should then represent the data I was trying to share. Note that you will need to replace the path name for the downloaded zip file, and that the parse_file function will create a temporary directory:

I'm quite far into the development of a game using SDL, OpenGL and C++ and am looking for ways to optimize the way the game switches between GLSL shaders for lots of different objects of different types. This is much more of a C++ question than an OpenGL question. However, I still want to provide as much context as I can, as I feel some justification is needed as to why the proposed Shader class I need, needs to be created / deleted the way that it is.

The first four sections are my justifications, journey & attempts leading up to this point, however my question can likely be answered by just the final section alone and I've intentionally written it as a bit of a tldr.

I've seen many implementations online of OpenGL shaders being created, compiled and deleted all in the same function when game objects are created during gameplay. This has proven to be inefficient and far too slow in particular sections of my game. Thus, I've required a system that creates and compiles shaders during a load-time and then intermittently uses/swaps between them during game-time before being deleted later.

This has lead to the creation of a class(Shader) that manages OpenGL shaders. Each instance of the class should manage one unique OpenGL shader each and contains some complex behavior around the shader type, where it's loaded in from, where it's used, the uniform variables it takes, etc.

With this said, the most important role of this class is to store the GLuint variable id that is returned from glCreateShader(), and manage all OpenGL calls that relate to the OpenGL shader with this id. I understand that this is effectively futile given the global nature of OpenGL(as anywhere in the program could technically call glDeleteShader() with the matching id and break the class), however for the purposes of intentionally encapsulating all OpenGL calls to very specific areas throughout the entire codebase this system will drastically reduce code-complexity.

The most "automatic" way to manage this GLuint id, would be to invoke glCreateShader() on the object's construction and glDeleteShader() on the object's destruction. This guarantees(within OpenGL limits) that the OpenGL shader will exist for the entire lifetime of the C++ Shader object and eliminates the need to call some void createShader() and deleteShader() functions.

This is all well and good, however problems soon arise when considering what happens if this object is copied. What if a copy of this object is destructed? That means that glDeleteShader() will be called and effectively break all copies of the shader object.

What about simple mistakes like accidentally invoking std::vector::push_back() in a vector of Shaders? Various std::vector methods can invoke the constructor / copy constructor / destructor of their type, which can result in the same problem as above.

Okay then... how about we do create some void createShader() and deleteShader() methods even if it's messy? Unfortunately this just defers the above problem, as once again any calls that modify the OpenGL shader will desynchronize / outright break all copies of a shader class with the same id. I've limited the OpenGL calls to glCreateShader() and glDeleteShader() in this example to keep things simple, however I should note that there are many other OpenGL calls in the class that would make creating various instance/static variables that keep track of instance copies far too complicated to justify doing it this way.

The last point I want to make before jumping into the class design below is that for a project as large as a raw C++, OpenGL and SDL Game, I'd prefer if any potential OpenGL mistakes I make generate compiler errors versus graphical issues that are harder to track down. This can be reflected in the class design below.

It is for the above reasons that I have elected to:

• Make the constructor private.
• Provide a public static create function that returns a pointer to a new Shader object in place of a constructor.
• Make the copy constructor private.
• Make the operator= private (Although this might not be necessary).
• Make the destructor private.
• Put calls to glCreateShader() in the constructor and glDeleteShader() in the destructor, to have OpenGL shaders exist for the lifetime of this object.
• As the create function invokes the new keyword(and returns the pointer to it), the place with the outside call to Shader::create() must then invoke delete manually (more on this in a second).

To my understanding, the first two bullet points utilize a factory pattern and will generate a compiler error should a non-pointer type of the class be attempted to be created. The third, fourth and fifth bullet points then prevent the object from being copied. The seventh bullet point then ensures that the OpenGL Shader will exist for the same lifetime of the C++ Shader object.

The only thing I'm not a huge fan of in the above, is the new/delete calls. They also make the glDeleteShader() calls in the destructor of the object feel inappropriate given the encapsulation that the class is trying to achieve. Given this, I opted to:

• change the create function to return a std::unique_ptr of the Shader type instead of a Shader pointer.

The create function then looked like this: