The discussion revolves around the challenges of connecting frontend and backend components in web and app development. Participants explore various aspects of this topic, including the role of API keys, server requirements, and the implications of using certain coding approaches.
Participants do not reach a consensus on the best approach to connect frontend and backend, with multiple competing views and uncertainties expressed throughout the discussion.
Some participants mention the need for a foundational understanding of web protocols and server configurations, indicating that there may be gaps in knowledge that affect their ability to connect frontend and backend effectively.
geekynerd said:
That’s certainly a sober view. Taking a step backwards is probably the right thing to do. Especially in the context of this “vibe” approach. Re-reading my answer in that context it must have sounded like downright gibberish!DaveC426913 said:
yeah i have made some webpages and hosted some static webpagesDaveC426913 said:
please dont share those website with anyone and that spark and stream website open the website in pc and hover over the image. and please i request you do not share this website with anyonegeekynerd said:
NO.sbrothy said:
sbrothy said:
They are bots used by the big search engine companies (mainly Google now, but some others as well) to archive discussion forum pages and make them available to their search users. So even if a post or thread gets deleted (or modified in this case), using the right search terms can turn up those archived pages as originally posted.geekynerd said:
This is IMHO a good example of the dangers inherent in the so called “vibe” method. Without a knowledge of the basic workings of the net, protocols, etc, the traps are legion.berkeman said:
I’m well aware I was being inappropiately cheeky here. Hence the emoticons. It was a tongue-in-cheek suggestion!sbrothy said:I’m almost loathe to suggest/“warn” of this, but is it possible that this forum needs a “vibe” section?
So, when I asked ChatGPT to write a birthday calculator for my kitten for fun, that was Vibe Coding, eh?sbrothy said:I’m almost loathe to suggest/“warn” of this, but is it possible that this forum needs a “vibe” section?
If you're using a web server such as Apache or Windows IIS there is (or possibly should be) a file called robots.txt (Google Search Central) (If you just google "robots.txt" there are quite a few videos explaining the concept) in the root of the server describing your server's attitude towards these "crawlers". Be warned that they are guidelines only though. A malicious robot might well just ignore it.geekynerd said:
I would put Shodan in that category. Since they crawl the web looking for every available port on any public facing IP address, they aren't paying any attention to stuff like a text file on port 80 or 443 (http and https for you vibe coders). The last time that I put a server on the internet, they knew about it within a few hours - including which ports were exposed and what server I was running. Within days, I had servers in Europe and Russia hitting those ports trying to break in.sbrothy said:
#ifndef COMPLEX_HPP
#define COMPLEX_HPP
#include <iostream>
class complex
{
protected:
double m_real;
double m_imag;
public:
complex();
explicit complex(const double real, const double imag = 0.0);
complex(const complex &other);
double real() const;
double imag() const;
void set_real(const double real);
void set_imag(const double imag);
complex operator+(const complex &rhs) const;
complex operator-(const complex &rhs) const;
complex operator*(const complex &rhs) const;
complex operator/(const complex &rhs) const;
complex &operator+=(const complex &rhs);
complex &operator-=(const complex &rhs);
complex &operator*=(const complex &rhs);
complex &operator/=(const complex &rhs);
complex operator+() const;
complex operator-() const;
bool operator==(const complex &rhs) const;
bool operator!=(const complex &rhs) const;
friend std::ostream &operator<<(std::ostream &os, const complex &c);
friend std::istream &operator>>(std::istream &is, complex &c);
};
// Default constructor
complex::complex()
: m_real(0.0), m_imag(0.0)
{
}
// Explicit constructor
complex::complex(const double real, const double imag)
: m_real(real), m_imag(imag)
{
}
// Copy constructor
complex::complex(const complex &other)
: m_real(other.m_real), m_imag(other.m_imag)
{
}
// Getters
double complex::real() const
{
return m_real;
}
double complex::imag() const
{
return m_imag;
}
// Setters
void complex::set_real(const double real)
{
m_real = real;
}
void complex::set_imag(const double imag)
{
m_imag = imag;
}
// Arithmetic operators
complex complex::operator+(const complex &rhs) const
{
return complex(m_real + rhs.m_real, m_imag + rhs.m_imag);
}
complex complex::operator-(const complex &rhs) const
{
return complex(m_real - rhs.m_real, m_imag - rhs.m_imag);
}
complex complex::operator*(const complex &rhs) const
{
return complex(
m_real * rhs.m_real - m_imag * rhs.m_imag,
m_real * rhs.m_imag + m_imag * rhs.m_real
);
}
complex complex::operator/(const complex &rhs) const
{
double denom = rhs.m_real * rhs.m_real + rhs.m_imag * rhs.m_imag;
return complex(
(m_real * rhs.m_real + m_imag * rhs.m_imag) / denom,
(m_imag * rhs.m_real - m_real * rhs.m_imag) / denom
);
}
// Compound assignment operators
complex &complex::operator+=(const complex &rhs)
{
m_real += rhs.m_real;
m_imag += rhs.m_imag;
return *this;
}
complex &complex::operator-=(const complex &rhs)
{
m_real -= rhs.m_real;
m_imag -= rhs.m_imag;
return *this;
}
complex &complex::operator*=(const complex &rhs)
{
double real = m_real * rhs.m_real - m_imag * rhs.m_imag;
double imag = m_real * rhs.m_imag + m_imag * rhs.m_real;
m_real = real;
m_imag = imag;
return *this;
}
complex &complex::operator/=(const complex &rhs)
{
double denom = rhs.m_real * rhs.m_real + rhs.m_imag * rhs.m_imag;
double real = (m_real * rhs.m_real + m_imag * rhs.m_imag) / denom;
double imag = (m_imag * rhs.m_real - m_real * rhs.m_imag) / denom;
m_real = real;
m_imag = imag;
return *this;
}
// Unary operators
complex complex::operator+() const
{
return *this;
}
complex complex::operator-() const
{
return complex(-m_real, -m_imag);
}
// Comparison operators
bool complex::operator==(const complex &rhs) const
{
return m_real == rhs.m_real && m_imag == rhs.m_imag;
}
bool complex::operator!=(const complex &rhs) const
{
return !(*this == rhs);
}
// Stream operators
std::ostream &operator<<(std::ostream &os, const complex &c)
{
os << "(" << c.m_real << (c.m_imag >= 0 ? "+" : "") << c.m_imag << "i)";
return os;
}
std::istream &operator>>(std::istream &is, complex &c)
{
char ch;
is >> ch; // skip '('
if (ch != '(') {
is.setstate(std::ios::failbit);
return is;
}
is >> c.m_real >> c.m_imag >> ch; // read real, imag, and ')'
if (ch != ')') {
is.setstate(std::ios::failbit);
}
return is;
}#ifndef COMPLEX_HPP
#define COMPLEX_HPP
#if __cplusplus < 202002L
#error "C++20 or later is required."
#endif
#include <iostream>
#include <concepts>
#include <type_traits>
#include <cmath>
template<typename T>
concept AllowedType = std::same_as<T, int> ||
std::same_as<T, long> ||
std::same_as<T, long long> ||
std::same_as<T, float> ||
std::same_as<T, double>;
template<AllowedType T>
class complex
{
protected:
T m_real;
T m_imag;
public:
complex();
explicit complex(const T, const T);
complex(const complex<T>&);
T real() const;
T imag() const;
void set_real(const T);
void set_imag(const T);
complex<T>& operator=(const complex<T>&);
complex<T> operator+(const complex<T>&) const;
complex<T> operator-(const complex<T>&) const;
complex<T> operator*(const complex<T>&) const;
complex<T> operator/(const complex<T>&) const;
complex<T>& operator+=(const complex<T>&);
complex<T>& operator-=(const complex<T>&);
complex<T>& operator*=(const complex<T>&);
complex<T>& operator/=(const complex<T>&);
template<AllowedType U>
friend std::ostream& operator<<(std::ostream&, const complex<U>&);
template<AllowedType U>
friend std::istream& operator>>(std::istream&, complex<U>&);
};
// -------------------- Implementations --------------------
template<AllowedType T>
complex<T>::complex()
: m_real(0), m_imag(0)
{
}
template<AllowedType T>
complex<T>::complex(const T r, const T i)
: m_real(r), m_imag(i)
{
}
template<AllowedType T>
complex<T>::complex(const complex<T>& other)
: m_real(other.m_real), m_imag(other.m_imag)
{
}
template<AllowedType T>
T complex<T>::real() const
{
return m_real;
}
template<AllowedType T>
T complex<T>::imag() const
{
return m_imag;
}
template<AllowedType T>
void complex<T>::set_real(const T r)
{
m_real = r;
}
template<AllowedType T>
void complex<T>::set_imag(const T i)
{
m_imag = i;
}
template<AllowedType T>
complex<T>& complex<T>::operator=(const complex<T>& other)
{
m_real = other.m_real;
m_imag = other.m_imag;
return *this;
}
template<AllowedType T>
complex<T> complex<T>::operator+(const complex<T>& rhs) const
{
return complex<T>(m_real + rhs.m_real, m_imag + rhs.m_imag);
}
template<AllowedType T>
complex<T> complex<T>::operator-(const complex<T>& rhs) const
{
return complex<T>(m_real - rhs.m_real, m_imag - rhs.m_imag);
}
template<AllowedType T>
complex<T> complex<T>::operator*(const complex<T>& rhs) const
{
T r = m_real * rhs.m_real - m_imag * rhs.m_imag;
T i = m_real * rhs.m_imag + m_imag * rhs.m_real;
return complex<T>(r, i);
}
template<AllowedType T>
complex<T> complex<T>::operator/(const complex<T>& rhs) const
{
T denom = rhs.m_real * rhs.m_real + rhs.m_imag * rhs.m_imag;
T r = (m_real * rhs.m_real + m_imag * rhs.m_imag) / denom;
T i = (m_imag * rhs.m_real - m_real * rhs.m_imag) / denom;
return complex<T>(r, i);
}
template<AllowedType T>
complex<T>& complex<T>::operator+=(const complex<T>& rhs)
{
m_real += rhs.m_real;
m_imag += rhs.m_imag;
return *this;
}
template<AllowedType T>
complex<T>& complex<T>::operator-=(const complex<T>& rhs)
{
m_real -= rhs.m_real;
m_imag -= rhs.m_imag;
return *this;
}
template<AllowedType T>
complex<T>& complex<T>::operator*=(const complex<T>& rhs)
{
T r = m_real * rhs.m_real - m_imag * rhs.m_imag;
T i = m_real * rhs.m_imag + m_imag * rhs.m_real;
m_real = r;
m_imag = i;
return *this;
}
template<AllowedType T>
complex<T>& complex<T>::operator/=(const complex<T>& rhs)
{
T denom = rhs.m_real * rhs.m_real + rhs.m_imag * rhs.m_imag;
T r = (m_real * rhs.m_real + m_imag * rhs.m_imag) / denom;
T i = (m_imag * rhs.m_real - m_real * rhs.m_imag) / denom;
m_real = r;
m_imag = i;
return *this;
}
template<AllowedType T>
std::ostream& operator<<(std::ostream& out, const complex<T>& c)
{
out << '(' << c.m_real;
if (c.m_imag >= 0) {
out << '+';
}
out << c.m_imag << 'i' << ')';
return out;
}
template<AllowedType T>
std::istream& operator>>(std::istream& in, complex<T>& c)
{
char ch;
T r, i;
in >> ch;
if (ch != '(') {
in.setstate(std::ios::failbit);
return in;
}
in >> r >> i >> ch;
if (ch != 'i') {
in.setstate(std::ios::failbit);
return in;
}
in >> ch;
if (ch != ')') {
in.setstate(std::ios::failbit);
return in;
}
c.m_real = r;
c.m_imag = i;
return in;
}
#endif // COMPLEX_HPPokayberkeman said:
makes us be addicted to it. hope you enjoyed vibe codingsbrothy said: